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

NeuralNetworks/Dependances/pytorch.py

@@ -1,111 +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.
-
-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

@@ -1,89 +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 ..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

@@ -1,31 +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 ..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/inference.py

@@ -1,26 +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 ..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/dynamic_learning_rate.py

@@ -1,79 +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 ..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

@@ -1,19 +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 ..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

@@ -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 ..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 ()

NeuralNetworks/UI/Learnings.py

@@ -1,45 +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 ..Dependances import plt, np
-
-def learnings(*nets):
-
-    # --- Initialisation de la figure ---
-    fig, ax1 = plt.subplots()
-    fig.set_figheight(5)
-    fig.set_figwidth(5)
-
-    # --- Définition des limites des axes ---
-    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)
-
-    # --- Tracé des courbes de pertes pour chaque réseau ---
-    for k, net in enumerate(nets):
-        ax1.plot(
-            np.arange(1, len(all_learnings[k]) + 1),
-            all_learnings[k],
-            label=net.name
-        )
-    ax1.set_xlabel("Epochs")
-    ax1.set_ylabel("Learning rate")
-    ax1.legend(loc="upper left")
-    ax1.grid(True)
-    
-    plt.yscale('log', nonpositive='mask')
-    # --- Affichage ---
-    plt.legend()
-    plt.xlabel("Epoch")
-    plt.ylabel("Learning rate")
-    fig.canvas.draw_idle()
-    plt.tight_layout()
-    plt.ion()  # mode interactif
-    plt.show()

NeuralNetworks/UI/Losses.py

@@ -1,45 +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 ..Dependances import plt, np
-
-def losses(*nets):
-
-    # --- Initialisation de la figure ---
-    fig, ax1 = plt.subplots()
-    fig.set_figheight(5)
-    fig.set_figwidth(5)
-
-    # --- Définition des limites des axes ---
-    all_losses = [[loss for loss in 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)
-    plt.xlim(1, lenlosses)
-
-    # --- Tracé des courbes de pertes pour chaque réseau ---
-    for k, net in enumerate(nets):
-        ax1.plot(
-            np.arange(1, len(all_losses[k]) + 1),
-            all_losses[k],
-            label=net.name
-        )
-    ax1.set_xlabel("Epochs")
-    ax1.set_ylabel("Loss")
-    ax1.legend(loc="upper left")
-    ax1.grid(True)
-    
-    plt.yscale('log', nonpositive='mask')
-    # --- Affichage ---
-    plt.legend()
-    plt.xlabel("Epoch")
-    plt.ylabel("Résidus")
-    fig.canvas.draw_idle()
-    plt.tight_layout()
-    plt.ion()  # mode interactif
-    plt.show()

neuralnetworks-0.2.5.dist-info/RECORD

@@ -1,20 +0,0 @@
-NeuralNetworks/__init__.py,sha256=DSCQD_dezpOEjqAGUSQsocNYmNq8STPHZaLjIXXLCF8,668
-NeuralNetworks/Dependances/__init__.py,sha256=qEpDbSD8cCq-E5XVisNUVf3kZOYopDnQWToyRefPgKE,1227
-NeuralNetworks/Dependances/matplot.py,sha256=elS8u6DZHYP-8mHEpYNOw3jDzhCAWTld9tm3OAD46zw,957
-NeuralNetworks/Dependances/pytorch.py,sha256=RQlSV3-8uHAoEgK0FBae7O4Mdug7h_MY--sN1fK59qw,3329
-NeuralNetworks/MLP/FourierFeatures.py,sha256=klgRM1HK09oA2NRMDxQMjJJ-WoUd5hV1ip5hHe9rHjI,3250
-NeuralNetworks/MLP/Layers.py,sha256=WAksXsiMxaClyYTxPhlyQbwwj9qTtXs3EWCO1RqjUHY,945
-NeuralNetworks/MLP/__init__.py,sha256=v7h4Vcmay0_A83spe67HhT7TQ7cSKQX4eVVBJhzEWfk,3052
-NeuralNetworks/MLP/inference.py,sha256=9aL7pUx1LTVvrc6UYHX049UjODTgHY6cweFcp2gequQ,853
-NeuralNetworks/Trainer/__init__.py,sha256=v0qKqx9XkYWkuouNNy0jTHQ_cZqYhFj98qrwSXlDXy0,1711
-NeuralNetworks/Trainer/dynamic_learning_rate.py,sha256=1JAD-k0cjdL_71zGeeCUFOa61H4PzFITDjZ2nK0TzXU,2340
-NeuralNetworks/Trainer/sample_data.py,sha256=7waC9colb7DXU4yKMcgcCnPG3Guv-isipcgVHJPPCNE,673
-NeuralNetworks/Trainer/train.py,sha256=NAbHFKg4hl96OXq_i63lcRYwrPHiuKu7ihexakhpgDY,3182
-NeuralNetworks/UI/Learnings.py,sha256=4TBR5pcjyoBeL7eikNKM6xn25jnqL-mWT7hbrt9q-Gw,1418
-NeuralNetworks/UI/Losses.py,sha256=Tu5xuDiutR9a4xcZKpyWN_tzSDu3_fImEf8FbAEehio,1378
-NeuralNetworks/UI/__init__.py,sha256=L96xwQZJ-HoqqOGxaheosiDKHR3mRopuXkif--rO1J4,409
-neuralnetworks-0.2.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-neuralnetworks-0.2.5.dist-info/METADATA,sha256=FjTIFWlGmzIjQmWhFLnTuUI7MfNl0U5jb7EjRQJ7lh8,18349
-neuralnetworks-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuralnetworks-0.2.5.dist-info/top_level.txt,sha256=h18nmC1BX7avyAAwKh0OQWezxgXmOpmVtbFq-8Mcbms,15
-neuralnetworks-0.2.5.dist-info/RECORD,,