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

NeuralNetworks/{Dependances/matplot.py → _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

NeuralNetworks/_Dependances/pytorch.py

@@ -0,0 +1,125 @@
+# 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.
+
+import os
+
+import platform
+
+import torch
+import torch.optim as optim
+import torch.nn as nn
+
+from torch.amp import autocast, GradScaler
+
+import visualtorch
+
+pi2 = 2 * torch.pi
+
+def get_best_device ():
+
+    os_name = platform.system ().lower ()
+
+    # =========== APPLE SILICON (macOS) ===========
+    if os_name == 'darwin':
+        if torch.backends.mps.is_available ():
+            return torch.device ('mps')
+
+    # =========== WINDOWS ===========
+    if os_name == 'windows':
+        # 1) CUDA
+        if torch.cuda.is_available ():
+            return torch.device ('cuda')
+
+    # =========== LINUX ===========
+    if os_name == 'linux':
+        # 1) CUDA (Nvidia)
+        if torch.cuda.is_available ():
+            return torch.device ('cuda')
+        # 2) ROCm (AMD)
+        elif hasattr (torch.backends, 'hip') and torch.backends.hip.is_available ():
+            return torch.device ('cuda')
+
+        # 3) Intel oneAPI / XPU
+        elif hasattr (torch, 'xpu') and torch.xpu.is_available ():
+            return torch.device ('xpu')
+
+    # =========== Unknown OS ===========
+    return torch.device ('cpu')
+    
+device = get_best_device (); dev = str (device)
+scaler = GradScaler (dev)
+
+# --- Optimisations CUDA ---
+# Accélération des convolutions et matmul
+torch.backends.cudnn.enabled = True
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cuda.allow_fp16_bf16_reduction_math_sdp(True)
+torch.backends.cudnn.allow_tf32 = True
+
+# Paramètres autograd
+torch._inductor.config.max_autotune = 'max'
+torch.set_float32_matmul_precision('medium')
+
+def tensorise(obj):
+    return torch.as_tensor(obj, dtype=torch.float32)
+
+class Container:
+    def __init__ (self, dictionnaire : dict):
+        self.D = dictionnaire
+
+    def __repr__ (self):
+        return "\n".join(self.D.keys())
+
+    def get (self, name : str):
+        value = self.D.get (str(name))
+        if value is None:
+            fall_back = list(self.D.keys ())[0]
+            print(f"Warning: '{str(name)}' not recognized, falling back to '{fall_back}'")
+            value = self.D.get (fall_back)
+        return value
+
+norms = Container ({
+    'Relu'     : nn.ReLU      (),
+    'LeakyRelu': nn.LeakyReLU (),
+    'ELU'      : nn.ELU       (),
+    'SELU'     : nn.SELU      (),
+    'GELU'     : nn.GELU      (),
+    'Mish'     : nn.Mish      (),
+    'Sigmoid'  : nn.Sigmoid   (),
+    'Tanh'     : nn.Tanh      (),
+    'Hardtanh' : nn.Hardtanh  (),
+    'Softplus' : nn.Softplus  (),
+    'Softsign' : nn.Softsign  ()
+})
+
+crits = Container ({
+    'MSE'                  : nn.MSELoss                  (reduction='none'),
+    'L1'                   : nn.L1Loss                   (reduction='none'),
+    'SmoothL1'             : nn.SmoothL1Loss             (reduction='none'),
+    'SoftMarginLoss'       : nn.SoftMarginLoss           (reduction='none'),
+    'Huber'                : nn.HuberLoss                (reduction='none'),
+    'CrossEntropy'         : nn.CrossEntropyLoss         (reduction='none'),
+    'KLDiv'                : nn.KLDivLoss                (reduction='none'),
+    'PoissonNLL'           : nn.PoissonNLLLoss           (reduction='none'),
+    'MultiLabelSoftMargin' : nn.MultiLabelSoftMarginLoss (reduction='none')
+})
+
+optims = Container ({
+    'Adam'      : optim.Adam     ,
+    'Adadelta'  : optim.Adadelta ,
+    'Adafactor' : optim.Adafactor,
+    'AdamW'     : optim.AdamW    ,
+    'Adamax'    : optim.Adamax   ,
+    'ASGD'      : optim.ASGD     ,
+    'NAdam'     : optim.NAdam    ,
+    'RAdam'     : optim.RAdam    ,
+    'RMSprop'   : optim.RMSprop  ,
+    'Rprop'     : optim.Rprop    ,
+    'SGD'       : optim.SGD
+})
+
+torch.cuda.empty_cache ()

NeuralNetworks/_Dependances/tools.py

@@ -0,0 +1,15 @@
+# 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.
+
+import torch
+from .pytorch import device
+
+pi = torch.pi
+e = torch.e
+
+def rglen(liste : list):
+    return range(len(liste))

NeuralNetworks/_UI/Learnings.py

@@ -0,0 +1,31 @@
+# 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 plt, np, FixedLocator
+from ._plot import plot, init_plot
+
+def learnings (*nets           , #
+    fig_size : int = 5         , #
+    color    : str = "#888888"): #
+
+    fig, ax = init_plot (fig_size, color)
+    all_learnings = [[lr for lr in net.learnings] for net in nets]
+
+    if max (len (lst) for lst in all_learnings) == 1:
+        lenlearnings = 2
+    else:
+        lenlearnings = max (len (lst) for lst in all_learnings)
+
+    plt.xlim (1, lenlearnings)
+    plt.ylim (10 ** (np.floor (np.log10 (np.min (all_learnings)))),
+              10 ** (np.ceil  (np.log10 (np.max (all_learnings)))))
+    
+    for k, net in enumerate (nets):
+        ax.plot (np.arange(1, len (all_learnings [k]) + 1),
+            all_learnings [k], label = net.name)
+
+    plot (ax, "Epochs", "Taux d'apprentissage", "")

NeuralNetworks/_UI/Losses.py

@@ -0,0 +1,48 @@
+# 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 plt, np, FixedLocator, torch
+from ._plot import plot, init_plot
+
+def losses (*nets                 , #
+    fuse_losses : bool = True     , #
+    names       : list = None     , #
+    fig_size    : int = 5         , #
+    color       : str = "#888888"): #
+
+    fig, ax = init_plot (fig_size, color)
+
+    if fuse_losses:
+        all_losses = [[np.mean (losses) for losses in net.losses] for net in nets]
+    else:
+        all_losses = [net.losses for net in nets]
+    
+    if max (len (lst) for lst in all_losses) == 1:
+        lenlosses = 2
+    else:
+        lenlosses = max (len (lst) for lst in all_losses)
+
+    all_losses = np.array (all_losses)
+    plt.xlim (1, lenlosses)
+    plt.ylim (10 ** (np.floor (np.log10 (np.min (all_losses)))),
+              10 ** (np.ceil  (np.log10 (np.max (all_losses)))))
+
+    if fuse_losses:
+
+        for k, net in enumerate (nets):
+            ax.plot (np.arange(1, len (all_losses [k]) + 1),
+                all_losses[k], label=net.name)
+    else:
+
+        if names is None:
+            names = range (all_losses.shape [-1])
+        for k, net in enumerate(nets):
+            for i in range (all_losses.shape [-1]):
+                ax.plot (np.arange (1, len (all_losses [k] [:, i]) + 1),
+                    all_losses [k] [:, i], label = f"{net.name} : {names [i]}")
+
+    plot (ax, "Epochs", "Résidus", "")

NeuralNetworks/{UI → _UI}/__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

NeuralNetworks/_UI/_plot.py

@@ -0,0 +1,50 @@
+# 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 np, plt, FixedLocator
+
+def init_plot (fig_size : int = 5, color : str = "#888888"):
+    
+    plt.rcParams['axes.facecolor']   = (0,0,0,0)
+    plt.rcParams ['text.color']      = color
+    plt.rcParams ['axes.labelcolor'] = color
+    plt.rcParams ['xtick.color']     = color
+    plt.rcParams ['ytick.color']     = color
+    plt.rcParams ['axes.edgecolor']  = color
+    plt.rcParams ['axes.titlecolor'] = color
+    plt.rcParams ['grid.color']      = color
+
+    fig, ax = plt.subplots ()
+    fig.set_figheight      (fig_size)
+    fig.set_figwidth       (fig_size)
+
+    return fig, ax
+
+def plot (ax,
+    x_title : str = "",
+    y_title : str = "",
+    title   : str = ""):
+
+    plt.title     (title)
+    ax.set_xlabel (x_title)
+    ax.set_ylabel (y_title)
+    ax.legend     (loc = "upper right", framealpha = 0, edgecolor = 'none')
+
+    ticks, minors = list (ax.get_xticks ()), []; ticks [0] = 1
+    for i in range( len (ticks) - 1):
+        minors.extend (np.linspace (ticks [i], ticks [i+1], 4, endpoint = False) [1:])
+    
+    ax.set_xticks              (ticks)
+    ax.xaxis.set_minor_locator (FixedLocator (minors))
+    
+    ax.grid    (which = "major", axis = "y", linewidth = 1.0)
+    ax.grid    (which = "minor", axis = "y", linestyle = ":", alpha = 0.5)
+    plt.yscale ('log', nonpositive='mask')
+    
+    plt.tight_layout     ()
+    plt.ion              ()
+    plt.show             ()

NeuralNetworks/__init__.py

@@ -1,18 +1,17 @@
 # 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.
 
 # Import des dépendances et utilitaires globaux (device, settings, tensorise, etc.)
-from .Dependances import norms, crits, optims, rglen, device, pi, e, tensorise
+from ._Dependances import norms, crits, optims, rglen, device, pi, e, tensorise
+from ._UI import losses, learnings
 
-# Modèle MLP principal + fonction d'entraînement associée
+from ._shared import Module
 from .MLP import MLP
-
+from .VAE import VAE
 from .Trainer import Trainer
 
-from .UI import *
-
-__version__ = "0.2.5"
+__version__ = "0.2.8"

NeuralNetworks/_shared/__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 .module import Module

NeuralNetworks/_shared/module.py

@@ -0,0 +1,115 @@
+# 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 nn, torch, device, np, onnx, simplify
+
+class Module (nn.Module):
+    """
+    Classe de base pour les modèles.
+    Gère le forward entraînement, l'inférence et le suivi des métriques.
+    """
+
+    def __init__ (self,
+        _name : str = "Net",
+        **Reconstruction_data): # Nom du modèle
+        """
+        Initialise le module.
+        """
+        super ().__init__ ()  
+        self.losses              = []                  # Tracker des résidus
+        self.learnings           = []                  # Tracker des lrs
+        self.name                = _name               # Nom du module
+        self.Reconstruction_data = Reconstruction_data # Données de reconstruction
+        
+
+    def _forward (self, x : torch.Tensor):
+        """
+        Forward interne à implémenter dans les classes filles.
+
+        Utile pour VAEs :
+        Si la sortie d'entrainement est différente de la sortie d'utilisation,
+        alors redéfinir train_forward pour l'entrainement.
+        """
+        raise Exception ("_forward n'est pas défini dans la classe")
+
+    def train_forward (self, x : torch.Tensor): # Forward de train (avec gradients)
+        return self._forward (x)
+
+    def forward(self, x: torch.Tensor):         # Forward d'inférence (sans gradients)
+        device = next (self.parameters ()).device
+    
+        with torch.no_grad ():
+            x = x.unsqueeze (0) if x.dim () == 1 else x
+            x = x.to (device)
+            output = self._forward (x)
+            return output.cpu ().numpy ().flatten ()
+
+    @property
+    def nb_params (self):
+        """
+        Affiche le nombre total de paramètres et ceux entraînables.
+        """
+        total     = sum (p.numel () for p in self.parameters ())
+        trainable = sum (p.numel () for p in self.parameters () if p.requires_grad)
+        print (f"Nombre total de paramètres : {total}")
+        print (f"Nombre de paramètres entraînables : {trainable}")
+
+    @property
+    def save(self):
+        state_dict = {
+            k: v.detach().cpu().numpy()
+            for k, v in self.state_dict().items()
+        }
+        np.savez(f"{self.name}.npz", allow_pickle = False, # Initialise l'enregistement
+            **state_dict                                 , # Données d'état
+            losses    = np.asarray(self.losses)          , # Données de loss
+            learnings = np.asarray(self.learnings)       , # Données de lr
+            **self.Reconstruction_data                   ) # Données de reconstruction
+
+    @classmethod
+    def load(cls, path, device="cpu"):
+        data = np.load(path, allow_pickle = False) # Lis les données
+        index = list(data.keys()).index('losses')  # Indice de séparation
+        
+        obj = cls (**{k: data[k] for k in list(data.keys())[index + 2:]})
+
+        state_dict = {
+            k: torch.from_numpy(data[k]).to(device)
+            for k in obj.state_dict().keys()
+        }
+        
+        obj.losses    = data ["losses"].tolist( )    # Charge les données de loss
+        obj.learnings = data ["learnings"].tolist( ) # Charge les données de lr
+        obj.load_state_dict  (state_dict)            # Charge le réseau
+
+        return obj
+
+    @property
+    def _dummy_input(self):
+        raise Exception ("_dummy_input n'est pas défini dans la classe")
+
+    @property
+    def onnx_save (self):
+        print ("Sauvegarde en format .onnx")
+        torch.onnx.export (self,
+            self._dummy_input,                           # Renseigne la input shape
+            f"{self.name}.onnx",                         # Nom du fichier de sauvegarde
+            opset_version  = 18,                         #
+            dynamo         = True,                       #
+            input_names    = ["inputs"],                 # Nom des inputs
+            output_names   = ["outputs"],                # Nom des outputs
+            dynamic_shapes = {                           
+                "x": {0: torch.export.Dim("batch_size")} #
+            }
+        )
+
+        print ("Simplification du .onnx")
+        onnx_model_simp, check = simplify (onnx.load (f"{self.name}.onnx"))
+        assert check
+
+        onnx.save (onnx_model_simp, f"{self.name}_simplified.onnx")
+        print ("Fin de l'enregistrement")

{neuralnetworks-0.2.5.dist-info → neuralnetworks-0.2.8.dist-info}/METADATA

@@ -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.8.dist-info/RECORD

@@ -0,0 +1,24 @@
+NeuralNetworks/__init__.py,sha256=FPSrB6FO7PmkWDgNhtohqAzWrSFUMTtl3GHrlRuO6n4,679
+NeuralNetworks/MLP/MLP.py,sha256=x6tpk-0Am628sOF1Bw6w4dcLCWe0uxDqCL4sMPNG1Qs,3333
+NeuralNetworks/MLP/_MLP_tools.py,sha256=gzOd--UPWHtV-ilBHl7PEVZxIP-1LGDQkS3gzsH6ipA,2590
+NeuralNetworks/MLP/__init__.py,sha256=mRd_O5i1o_xnMh0gHM1FYSWYlv2F_ghPCWntMc_6N88,377
+NeuralNetworks/Trainer/Trainer.py,sha256=8D4kiXBzk2jF00lAX-zyRL3rTgT_C-cN5mCZQrwq4PQ,5673
+NeuralNetworks/Trainer/_Trainer_tools.py,sha256=cCgxcKjYPhsMV1ByfPY7iiBNONQ0iVktzKuLq834RpM,5645
+NeuralNetworks/Trainer/__init__.py,sha256=5xvMMe7B96sfPEvdEVMOIC_hgKwOrdsIiE7KdtCMLtM,385
+NeuralNetworks/VAE/VAE.py,sha256=hKh2rJX-If-N41pZXZXur8az0GAaCSbpYNfa5Aq-u4w,4458
+NeuralNetworks/VAE/_VAE_tools.py,sha256=sR1nUm2DAdCpRt07vo8TZ9OEzvnnsbHETvVN3BrtLTE,355
+NeuralNetworks/VAE/__init__.py,sha256=O8Aa2CldKTWPQKuC6-597aEiE3I9wAmEias4Yuuaars,386
+NeuralNetworks/_Dependances/__init__.py,sha256=FD77Mr309XidFBHBdaUywt1mFvMlggbta5lZbTXkQ4w,741
+NeuralNetworks/_Dependances/pytorch.py,sha256=wYJ4GymdEDWiD_se3IPlSakOYrQIqGBkUSjH49VS8Sg,3996
+NeuralNetworks/_Dependances/tools.py,sha256=UoqyLVzgdKJcXk5lJzXjU7Z9ksMXVObVpSwAbuiezjQ,479
+NeuralNetworks/_UI/Learnings.py,sha256=uizcl2D4nWGM_IBeAbbotSUOfnSZKBlN54gdx6mEUCc,1181
+NeuralNetworks/_UI/Losses.py,sha256=nepuUWLaO1OmBBsy6Yv-YZsjva_-dHh4zR4y2NQSt0s,1731
+NeuralNetworks/_UI/__init__.py,sha256=1RW0P85U59OUnEguD3Z8jrUX1uaF3xp0KgVwL-sy0l8,416
+NeuralNetworks/_UI/_plot.py,sha256=x-KGr6VljIKcQ84XdBI7Ft63eNseHorg56K3ELGlecU,1772
+NeuralNetworks/_shared/__init__.py,sha256=bShz5M41mC9Rz_tGex5W_4v0iFi0YFxgSo5x2gLRxKs,383
+NeuralNetworks/_shared/module.py,sha256=hU6odU1syrzi3eMYG7xNchIhVaUDvX13-HIr9p4APoM,4648
+neuralnetworks-0.2.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+neuralnetworks-0.2.8.dist-info/METADATA,sha256=SIC3XH77VIVO8OehohtmfA57naZ90lCD_-z41XqhwuE,18086
+neuralnetworks-0.2.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+neuralnetworks-0.2.8.dist-info/top_level.txt,sha256=h18nmC1BX7avyAAwKh0OQWezxgXmOpmVtbFq-8Mcbms,15
+neuralnetworks-0.2.8.dist-info/RECORD,,

{neuralnetworks-0.2.5.dist-info → neuralnetworks-0.2.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

NeuralNetworks/Dependances/__init__.py

@@ -1,75 +0,0 @@
-# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
-# Copyright (C) 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 .matplot import *
-from .pytorch import *
-
-import numpy as np
-from PIL import Image
-
-import copy
-import subprocess
-import requests
-from io import BytesIO
-from tqdm import tqdm
-import plotly.graph_objects as go
-from IPython.display import display, clear_output
-
-from scipy.interpolate import griddata
-from sklearn.model_selection import train_test_split
-
-import math
-pi = math.pi
-e = math.e
-
-norms = lambda: print("""
-"Relu"
-"LeakyRelu"
-"ELU"
-"SELU"
-"GELU"
-"Mish"
-"Sigmoid"
-"Tanh"
-"Hardtanh"
-"Softplus"
-"Softsign"
-"""
-)
-
-crits = lambda: print("""
-"MSE"
-"L1"
-"SmoothL1"
-"Huber"
-"CrossEntropy"
-"KLDiv"
-"PoissonNLL"
-"MultiLabelSoftMargin"
-"""
-)
-
-optims = lambda: print("""
-"Adadelta"
-"Adafactor"
-"Adam"
-"AdamW"
-"Adamax"
-"ASGD"
-"NAdam"
-"RAdam"
-"RMSprop"
-"Rprop"
-"SGD"
-"""
-)
-
-def rglen(list):
-    return range(len(list))
-
-def fPrintDoc(obj):
-    return lambda: print(obj.__doc__)