NeuralNetworks 0.1.12__py3-none-any.whl → 0.2.2__py3-none-any.whl

NeuralNetworks/Dependances/__init__.py

@@ -0,0 +1,75 @@
+# 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__)

NeuralNetworks/Dependances/matplot.py

@@ -0,0 +1,25 @@
+# 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.
+
+import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
+
+plt.rcParams['figure.facecolor'] = (0,0,0,0)
+plt.rcParams['axes.facecolor']   = (0,0,0,0)
+grey_color = "#888888"
+
+# 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
+
+# Activation de la grille globale
+plt.rcParams['axes.grid']  = True
+plt.rcParams['grid.color'] = grey_color

NeuralNetworks/Dependances/pytorch.py

@@ -0,0 +1,111 @@
+# 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.
+
+import os
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+import platform
+
+import torch
+import torch.optim as optim
+import torch.nn as nn
+import torch.quantization as tq
+from torch.amp import autocast, GradScaler
+from torch.utils.data import TensorDataset, DataLoader
+
+from torchmetrics.image import PeakSignalNoiseRatio as PSNR
+from torchvision.transforms import ToTensor, Resize, Compose
+
+torch.cuda.empty_cache()
+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()
+
+# --- Optimisations CUDA ---
+# Accélération des convolutions et matmul
+torch.backends.cudnn.benchmark = True
+torch.backends.cudnn.enabled = True
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+
+# Paramètres autograd
+torch.autograd.set_detect_anomaly(False)
+torch.autograd.profiler.profile(enabled=False)
+torch.use_deterministic_algorithms(False)
+
+torch._inductor.config.max_autotune = "max"
+
+norm_list = {
+    "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()
+}
+
+crit_list = {
+    "MSE": nn.MSELoss(),
+    "L1": nn.L1Loss(),
+    "SmoothL1": nn.SmoothL1Loss(),
+    "Huber": nn.HuberLoss(),
+    "CrossEntropy": nn.CrossEntropyLoss(),
+    "KLDiv": nn.KLDivLoss(),
+    "PoissonNLL": nn.PoissonNLLLoss(),
+    "MultiLabelSoftMargin": nn.MultiLabelSoftMarginLoss()
+}
+
+def optim_list(params):
+    return {
+        "Adadelta": optim.Adadelta(params),
+        "Adafactor": optim.Adafactor(params),
+        "Adam": optim.Adam(params),
+        "AdamW": optim.AdamW(params),
+        "Adamax": optim.Adamax(params),
+        "ASGD": optim.ASGD(params),
+        "NAdam": optim.NAdam(params),
+        "RAdam": optim.RAdam(params),
+        "RMSprop": optim.RMSprop(params),
+        "Rprop": optim.Rprop(params),
+        "SGD": optim.SGD(params)
+    }
+
+def tensorise(obj):
+    return torch.as_tensor(obj, dtype=torch.float32, device='cpu')

NeuralNetworks/MLP/FourierFeatures.py

@@ -0,0 +1,89 @@
+# 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 ..Dependances import torch, nn, np
+
+class FourierEncoding (nn.Module):
+    """
+    Encodage de Fourier aléatoire pour enrichir la représentation des entrées.
+
+    Cette couche projette les entrées dans un espace fréquentiel à l'aide
+    d'une matrice de projection apprise, puis applique des fonctions sinus
+    et cosinus afin de capturer des variations à haute fréquence.
+
+    Parameters
+    ----------
+    nb_fourier : int
+        Nombre de composantes de Fourier.
+    input_size : int
+        Dimension des entrées.
+    sigma : float
+        Écart-type utilisé pour l'initialisation de la matrice de projection.
+    """
+    def __init__ (self, nb_fourier, input_size, sigma):
+        super ().__init__ ()
+        self.B = nn.Parameter (torch.randn (nb_fourier, input_size) * sigma)
+
+    def forward (self, x):
+        """
+        Applique l'encodage de Fourier aux entrées.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Tensor d'entrée de shape `(N, input_size)`.
+
+        Returns
+        -------
+        torch.Tensor
+            Tensor encodé de shape `(N, 2 * nb_fourier)`, correspondant
+            à la concaténation des cosinus et sinus.
+        """
+        vp = 2 * np.pi * x @ self.B.T
+        return torch.cat ((torch.cos (vp), torch.sin (vp)), dim = -1)
+
+def encode (input_size, output_size, sigmas, fourier_input_size, nb_fourier):
+    """
+    Construit les modules d'encodage (Fourier ou identité) et la couche de fusion associée.
+
+    Si `sigmas` est `None`, aucun encodage de Fourier n'est appliqué et les
+    entrées sont transmises directement au réseau.
+    Sinon, plusieurs encodages de Fourier sont créés (un par sigma), et
+    leurs sorties sont fusionnées via une couche linéaire.
+
+    Parameters
+    ----------
+    input_size : int
+        Dimension des entrées.
+    output_size : int
+        Dimension de sortie du réseau.
+    sigmas : list[float] ou None
+        Liste des paramètres sigma pour les encodages de Fourier.
+    fourier_input_size : int
+        Dimension attendue après encodage (non utilisée directement ici,
+        mais conservée pour cohérence avec l'architecture globale).
+    nb_fourier : int
+        Nombre de composantes de Fourier par encodage.
+
+    Returns
+    -------
+    encodings : torch.nn.ModuleList (scripté)
+        Liste des modules d'encodage (Fourier ou identité).
+    f : torch.nn.Module (scripté)
+        Module de fusion des encodages (identité ou couche linéaire).
+    """
+    if sigmas is None:
+        encodings = nn.ModuleList (
+            [nn.Identity ()]
+        )
+        f = nn.Identity ()
+    else:
+        encodings = nn.ModuleList (
+            [FourierEncoding (nb_fourier, input_size, sigma) for sigma in sigmas]
+        )
+        f = nn.Linear (len (encodings) * output_size, output_size)
+    return torch.jit.script (encodings), torch.jit.script (f)

NeuralNetworks/MLP/Layers.py

@@ -0,0 +1,31 @@
+# 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 ..Dependances import torch, nn
+
+def create_layers(
+    input_size,
+    output_size,
+    hidden_layers,
+    sigmas,
+    fourier_input_size,
+    nb_fourier,
+    norm):
+
+    layer_list = [
+        nn.Linear (input_size if sigmas is None else 2 * nb_fourier, hidden_layers [0]),
+        norm
+    ]
+
+    for k in range (len (hidden_layers) - 1):
+        layer_list.extend ([
+            nn.Linear (hidden_layers [k], hidden_layers [k + 1]),
+            norm
+        ])
+    layer_list.append (nn.Linear (hidden_layers [-1], output_size))
+
+    return torch.jit.script (nn.Sequential (*layer_list))

NeuralNetworks/MLP/__init__.py

@@ -0,0 +1,99 @@
+# 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 ..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, nn.ReLU)
+        if self.norm is None:
+            print (f"Warning: '{norm}' not recognized, falling back to 'ReLU'")
+            self.norm = norm_list.get (norm, "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)

NeuralNetworks/MLP/inference.py

@@ -0,0 +1,26 @@
+# 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 ..Dependances import torch, np, device
+
+def infer (net, x):
+    with torch.no_grad ():
+        x = x.unsqueeze (0) if x.dim () == 1 else x
+
+        net = net.to (device)
+        x = x.to (device)
+        results_list = [net.model (encoding (x)) for encoding in net.encodings]
+        x = x.to ('cpu')
+
+        output = np.array (
+            net.f (
+                torch.cat (results_list, dim = 1)
+            ).cpu ().numpy ().flatten ()
+        )
+        net = net.to ('cpu')
+
+    return output

NeuralNetworks/Trainer/__init__.py

@@ -0,0 +1,51 @@
+# 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 ..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)

NeuralNetworks/Trainer/dynamic_learning_rate.py

@@ -0,0 +1,79 @@
+# 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 ..Dependances import np
+
+def generate_learning_rate (
+    Nb_iter,
+    X0,
+    mode = "smoother", 
+    first = 0.4,
+    second = 1,
+    Xi = 5e-4,
+    Xf = 1e-6):
+
+    infl = int (first * Nb_iter)
+    Plat = int (second * Nb_iter)
+
+    def smoothstep (x0, xa, n, m):
+        values = []
+        if m == "smooth":
+            for i in range (n):
+                t = i / (n - 1)          # t dans [0, 1]
+                s = t * t * (3 - 2 * t)  # smoothstep
+                x = x0 + (xa - x0) * s
+                values.append (x)
+        elif m == "smoother":
+            for i in range(n):
+                t = i / (n - 1)          # t dans [0, 1]
+                s = t * t * t * (t * (6 * t - 15) + 10)
+                x = x0 + (xa - x0) * s
+                values.append(x)
+        else:
+            raise ValueError("mode doit être 'smooth' ou 'smoother'")
+        return values
+    
+    cuv1 = smoothstep (X0, Xi, infl, mode)
+    cuv2 = smoothstep (Xi, Xf, Plat - infl, mode)
+    cuv3 = [Xf for _ in range (Plat, Nb_iter)]
+
+    return np.array (cuv1 + cuv2 + cuv3)
+
+def update_lr (losses, lrs, epoch, lr):
+
+    loss = losses[-1] + (losses[-1] - losses[0])/len(losses)
+
+    n = 9
+    # Points de contrôle (multiplicité finale = dérivée nulle)
+    P = np.array([
+        0.0,
+        0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
+        1.0, 1.0
+    ])
+    
+    # Coefficients binomiaux (précomputés UNE FOIS)
+    C = np.array([1, 9, 36, 84, 126, 126, 84, 36, 9, 1], dtype=float)
+
+    x = np.clip(loss, 0.0, 1.0)
+    t = np.sqrt(x)
+
+    u = 1.0 - t
+
+    # Bernstein vectorisé
+    y = (
+        C[0] * u**9 * P[0] +
+        C[1] * u**8 * t * P[1] +
+        C[2] * u**7 * t**2 * P[2] +
+        C[3] * u**6 * t**3 * P[3] +
+        C[4] * u**5 * t**4 * P[4] +
+        C[5] * u**4 * t**5 * P[5] +
+        C[6] * u**3 * t**6 * P[6] +
+        C[7] * u**2 * t**7 * P[7] +
+        C[8] * u * t**8 * P[8] +
+        C[9] * t**9 * P[9]
+    )
+    return np.clip (max(0.001 * y, lrs [epoch]), 0.0, lr)

NeuralNetworks/Trainer/sample_data.py

@@ -0,0 +1,19 @@
+# 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 ..Dependances import train_test_split
+
+def sample_data (inputs, outputs, test_size):
+    if test_size is None:
+        return inputs, inputs, outputs, outputs
+    else:
+        return train_test_split (
+            inputs,
+            outputs,
+            test_size = test_size,
+            random_state = 42
+        )

NeuralNetworks/Trainer/train.py

@@ -0,0 +1,75 @@
+# 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 ..Dependances import torch, GradScaler, device, tqdm, autocast
+
+from .dynamic_learning_rate import generate_learning_rate, update_lr
+
+def train_f (Trainer, num_epochs = 1, activate_tqdm = True):
+        dev = str (device)
+        scaler = GradScaler (dev)
+
+        lrs = generate_learning_rate (num_epochs, Trainer.init_lr)
+
+        Trainer.X_train = Trainer.X_train.to (device)
+        Trainer.y_train = Trainer.y_train.to (device)
+        n_samples = Trainer.X_train.size (0)
+
+        torch.cuda.empty_cache ()
+        for k, net in enumerate (Trainer.nets):
+            net = net.to (device)
+            net.learnings.append(Trainer.init_lr)
+
+            pbar = tqdm (
+                range (num_epochs),
+                desc = f"train epoch",
+                disable = not (activate_tqdm)
+            )
+
+            for epoch in pbar:
+                # Génération d'un ordre aléatoire des indices
+                perm = torch.randperm (n_samples, device = device)
+                epoch_loss = 0.0
+    
+                # --- Parcours des mini-batchs ---
+                for i in range (0, n_samples, Trainer.batch_size):
+                    idx = perm [i : i + Trainer.batch_size]
+    
+                    # Fonction interne calculant la perte et les gradients
+                    def closure ():
+                        Trainer.optims [k].zero_grad (set_to_none = True)
+                        with autocast (dev):
+                            loss = Trainer.crit (
+                                net.f (
+                                    torch.cat (
+            [net.model (encoding (Trainer.X_train [idx]))for encoding in net.encodings],
+            dim = 1
+                                    )
+                                ),
+                                Trainer.y_train[idx]
+                            )
+                            scaler.scale (loss).backward ()
+                            return loss
+    
+                    epoch_loss += closure()
+                    scaler.step (Trainer.optims [k])
+                    scaler.update ()
+    
+                # --- Stockage de la perte de l'époque ---
+                #Trainer.frequencies.append(net.encodings[0].B.detach().cpu().clone())
+                net.losses.append (epoch_loss.item ())
+                net.learnings.append (update_lr (net.losses [-20:], lrs, epoch, net.learnings[-1]))
+                for param_group in Trainer.optims [k].param_groups:
+                    param_group ['lr'] = net.learnings[-1]
+                
+                pbar.set_postfix(loss=f"{epoch_loss:.5f}",lr=f"{net.learnings[-1]:.5f}")
+                
+            net = net.to ('cpu')
+            net.learnings.pop(-1)
+        Trainer.X_train = Trainer.X_train.to ('cpu')
+        Trainer.y_train = Trainer.y_train.to ('cpu')
+        torch.cuda.empty_cache ()