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

NeuralNetworks/MLP/__init__.py

@@ -52,10 +52,10 @@ class MLP (nn.Module):
         super ().__init__ ()
 
         # --- Activation ---
-        self.norm = norm_list.get (norm, nn.ReLU)
+        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 (norm, "Relu")
+            print (f"Warning: '{norm}' not recognized, falling back to 'm is'")
+            self.norm = norm_list.get ("Relu")
 
         # --- Attributs ---
         self.losses = []

NeuralNetworks/__init__.py

@@ -9,15 +9,10 @@
 from .Dependances import norms, crits, optims, rglen, device, pi, e, tensorise
 
 # Modèle MLP principal + fonction d'entraînement associée
-from .MLP import MLP, losses
+from .MLP import MLP
 
 from .Trainer import Trainer
 
 from .UI import *
 
-from .Latent import Latent
-
-# Fonctions de chargement/preprocessing des images
-from .tools import image, MNIST, AirfRANS
-
-__version__ = "0.2.2"
+__version__ = "0.2.3"

neuralnetworks-0.2.3.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: NeuralNetworks
+Version: 0.2.3
+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
+Project-URL: Documentation, https://xxxfetraxxx.github.io/NeuralNetworks/
+Project-URL: Source, https://github.com/xXxFetraxXx/NeuralNetworks
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+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
+Dynamic: license-file
+
+# NeuralNetworks Module
+
+Module complet pour la création et l'entraînement de [MultiLayer Perceptrons](https://en.wikipedia.org/wiki/Multilayer_perceptron) (MLP)  
+avec encodage optionnel [Fourier Features](https://en.wikipedia.org/wiki/Random_feature#Random_Fourier_feature) et gestion automatique des pertes.
+
+---
+
+## Contenu principal
+
+### Classes
+
+#### `MLP` {#MLP}
+
+Cette classe fournit :
+
+- Un [MLP](https://en.wikipedia.org/wiki/Multilayer_perceptron) entièrement configurable (dimensions, activation).
+- Option d'encodage [Fourier Features](https://en.wikipedia.org/wiki/Random_feature#Random_Fourier_feature) sur les entrées.
+
+---
+
+##### Paramètres
+
+| **Paramètres**       | **Type**                                                                                         | **Optionnel** | **Description**                                                                |
+|----------------------|--------------------------------------------------------------------------------------------------|---------------|--------------------------------------------------------------------------------|
+| `input_size`         | [`int`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)         | Oui           | Taille des données en entrée au réseau. Default: `1`                           |
+| `output_size`        | [`int`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)         | Oui           | Taille des données en sortie au réseau. Default: `1`                           |
+| `hidden_layers`      | [`list[int]`](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)   | Oui           | Dimensions successives des couches intermédiaires du réseau. Default: `[1]`    |
+| `sigmas`             | [`list[float]`](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range) | Oui           | Liste de sigma pour encodages RFF. Si None : passthrough. Default: `None`      |
+| `fourier_input_size` | [`int`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)         | Oui           | WIP. Default: `2`                                                              |
+| `nb_fourier`         | [`int`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)         | Oui           | Nombre de fréquences utilisées pour les Fourier Features. Default: `8`         |
+| `norm`               | [`norm`](#norms)                                                                                 | Oui           | Type de normalisation / activation pour les couches cachées. Default: `'Relu'` |
+| `name`               | [`str`](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)                  | Oui           | Nom du réseau pour identification ou affichage. Default: `'Net'`               |
+
+##### Attributs
+
+- `losses : list[float]` — Historique des pertes cumulées lors de l'entraînement  
+- `learnings : list[float]` — Historique des taux d'apprentissage utilisées lors de l'entraînement  
+- `model : nn.Sequential` — MLP complet construit dynamiquement 
+- `name : str` — Nom du réseau
+
+---
+
+#### `Trainer`
+
+Cette classe fournit :
+
+- Méthode pour entraîner des réseaux avec mini-batchs et [Automatic Mixed Precision](https://docs.pytorch.org/tutorials/recipes/recipes/amp_recipe.html)
+
+##### Paramètres
+
+| **Paramètres** | **Type**                                                                                        | **Optionnel** | **Description**                                                                                                 |
+|----------------|-------------------------------------------------------------------------------------------------|---------------|-----------------------------------------------------------------------------------------------------------------|
+| `*nets`        | [`MLP`](#MLP)                                                                                   | Non           | Réseaux pour lesquels le trainer va entrainer.                                                                  |
+| `inputs`       | [`numpy.array(list[float])`](https://numpy.org/doc/stable/reference/generated/numpy.array.html) | Non           | Données en entrée au réseau.                                                                                    |
+| `outputs`      | [`numpy.array(list[float])`](https://numpy.org/doc/stable/reference/generated/numpy.array.html) | Non           | Données en sortie au réseau.                                                                                    |
+| `test_size`    | [`float`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)      | Oui           | Proportion des données à utiliser pendant l'entrainement. Si None : utilise toutes les données. Default: `None` |
+| `optim`        | [`optim`](#optims)                                                                              | Oui           | Nom de l’optimiseur à utiliser (doit exister dans `optims()`). Default: `'Adam'`                                |
+| `init_lr`      | [`float`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)      | Oui           | Taux d’apprentissage initial pour l’optimiseur. Default: `1e-3`                                                 |
+| `crit`         | [`crit`](#crits)                                                                                | Oui           | Fonction de perte à utiliser (doit exister dans `crits()`). Default: `MSE'`                                     |
+| `batch_size`   | [`int`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)        | Oui           | Taille des minibatchs. Default: `1024`                                                                          |
+
+##### `Trainer.train`
+
+Lancement d'un entrainement avec le trainer définit
+
+| **Paramètres**  | **Type**                                                                                 | **Optionnel** | **Description**                         |
+|-----------------|------------------------------------------------------------------------------------------|---------------|-----------------------------------------|
+| `num_epochs`    | [`int`](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex) | Oui           | Nombres d'itérations à effectuer.       |
+| `activate_tqdm` | [`boolean`](https://docs.python.org/3/library/stdtypes.html#boolean-type-bool)           | Oui           | Utilisation d'une barre de progression. |
+  
+---
+
+### Dictionnaires
+
+#### `norms()` {#norms}
+
+| **Valeurs**   | **Module PyTorch**                                                                         | **Description**                                                                                           |
+|---------------|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| `'ReLU'`      | [`nn.ReLU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.ReLU.html)           | Fonction d'activation ReLU classique (Rectified Linear Unit).                                             |
+| `'LeakyReLU'` | [`nn.LeakyReLU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.LeakyReLU.html) | ReLU avec un petit coefficient pour les valeurs négatives (paramètre `negative_slope`).                   |
+| `'ELU'`       | [`nn.ELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.ELU.html)             | Fonction d'activation ELU (Exponential Linear Unit), qui a une meilleure gestion des valeurs négatives.   |
+| `'SELU'`      | [`nn.SELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.SELU.html)           | SELU (Scaled Exponential Linear Unit), une version améliorée de l'ELU pour des réseaux auto-normalisants. |
+| `'GELU'`      | [`nn.GELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.GELU.html)           | GELU (Gaussian Error Linear Unit), une activation probabiliste basée sur une fonction gaussienne.         |
+| `'Mish'`      | [`nn.Mish()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Mish.html)           | ReLU différentiable en tout points avec passage négatif.                                                  |
+| `'Softplus'`  | [`nn.Softplus()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Softplus.html)   | Fonction d'activation qui approxime ReLU mais de manière lissée.                                          |
+| `'Sigmoid'`   | [`nn.Sigmoid()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Sigmoid.html)     | Fonction d'activation Sigmoid, qui produit une sortie entre 0 et 1.                                       |
+| `'Tanh'`      | [`nn.Tanh()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Tanh.html)           | Fonction d'activation Tanh, avec une sortie dans l'intervalle [-1, 1].                                    |
+| `'Hardtanh'`  | [`nn.Hardtanh()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Hardtanh.html)   | Variante de Tanh, avec des sorties limitées entre une plage spécifiée.                                    |
+| `'Softsign'`  | [`nn.Softsign()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Softsign.html)   | Fonction d'activation similaire à Tanh mais plus souple, avec des valeurs dans [-1, 1].                   |
+
+#### `crits()` {#crits}
+
+| **Valeurs**              | **Module PyTorch**                                                                                                       | **Description**                                                       |
+|--------------------------|--------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------|
+| `'MSE'`                  | [`nn.MSELoss`](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html)                                          | Perte utilisée pour les régressions.                                  |
+| `'L1'`                   | [`nn.L1Loss()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.L1Loss.html)                                     | Perte utilisée pour la régularisation.                                |
+| `'SmoothL1'`             | [`nn.SmoothL1Loss()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.SmoothL1Loss.html)                         | Perte moins sensible aux outliers.                                    |
+| `'Huber'`                | [`nn.HuberLoss()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.HuberLoss.html)                               | Perte moins affectée par les grands écarts.                           |
+| `'CrossEntropy'`         | [`nn.CrossEntropyLoss()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)                 | Perte utilisée pour les problèmes de classification multi-classes.    |
+| `'KLDiv'`                | [`nn.KLDivLoss()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.KLDivLoss.html)                               | Perte utilisée pour des modèles probabilistes.                        |
+| `'PoissonNLL'`           | [`nn.PoissonNLLLoss()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.PoissonNLLLoss.html)                     | Perte utilisée pour la modélisation de comptages.                     |
+| `'MultiLabelSoftMargin'` | [`nn.MultiLabelSoftMarginLoss()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.MultiLabelSoftMarginLoss.html) | Perte utilisée pour les problèmes de classification multi-étiquettes. |
+
+#### `optims()` {#optims}
+
+| **Valeurs**   | **Module PyTorch**                                                                               | **Description**                                                                                       |
+|---------------|--------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------|
+| `'Adadelta'`  | [`optim.Adadelta()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.Adadelta.html)   | Optimiseur basé sur les gradients adaptatifs, sans nécessité de réglage du taux d'apprentissage.      |
+| `'Adafactor'` | [`optim.Adafactor()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.Adafactor.html) | Optimiseur variant d'Adam avec une mise à jour plus efficace de la mémoire pour de grands modèles.    |
+| `'Adam'`      | [`optim.Adam()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.Adam.html)           | Optimiseur utilisant un gradient stochastique adaptatif avec des moyennes mobiles des gradients.      |
+| `'AdamW'`     | [`optim.AdamW()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.AdamW.html)         | Optimiseur avec une régularisation L2 (weight decay) distincte.                                       |
+| `'Adamax'`    | [`optim.Adamax()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.Adamax.html)       | Optimiseur utilisant une norme infinie pour les gradients, plus stable pour certaines configurations. |
+| `'ASGD'`      | [`optim.ASGD()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.ASGD.html)           | Optimiseur utilisé pour de grandes données avec une moyenne des gradients.                            |
+| `'NAdam'`     | [`optim.NAdam()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.NAdam.html)         | Optimiseur avec une adaptation des moments de second ordre.                                           |
+| `'RAdam'`     | [`optim.RAdam()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.RAdam.html)         | Optimiseur qui ajuste dynamiquement les moments pour stabiliser l'entraînement.                       |
+| `'RMSprop'`   | [`optim.RMSprop()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.RMSprop.html)     | Optimiseur utilisant une moyenne mobile des carrés des gradients pour réduire les oscillations.       |
+| `'Rprop'`     | [`optim.Rprop()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.Rprop.html)         | Optimiseur basé sur les mises à jour des poids indépendantes des gradients.                           |
+| `'SGD'`       | [`optim.SGD()`](https://docs.pytorch.org/docs/stable/generated/torch.optim.SGD.html)             | Optimiseur souvent utilisée avec un taux d'apprentissage constant ou ajusté.                          |
+ 
+---
+
+### `device`
+
+variable principale d'allocation des performances
+
+#### **Apple Silicon (macOS)**
+- Si le système d'exploitation est macOS (nommé `darwin` dans `platform.system()`), la fonction vérifie si l'accélérateur **Metal Performance Shaders** (MPS) est disponible sur l'appareil.
+  - Si MPS est disponible (`torch.backends.mps.is_available()`), l'appareil cible sera défini sur `'MPS'` (c'est un équivalent de CUDA pour les appareils Apple Silicon).
+  
+#### **Windows**
+- Si le système d'exploitation est Windows, la fonction vérifie d'abord si **CUDA** (NVIDIA) est disponible avec `torch.cuda.is_available()`. Si c'est le cas, le périphérique sera défini sur **CUDA**.
+  
+#### **Linux**
+- Si le système d'exploitation est Linux, plusieurs vérifications sont effectuées :
+  1. **CUDA** (NVIDIA) : Si `torch.cuda.is_available()` renvoie `True`, le périphérique sera défini sur `'CUDA'`.
+  2. **ROCm** (AMD) : Si le système supporte **ROCm** via `torch.backends.hip.is_available()`, l'appareil sera défini sur `'CUDA'` (ROCm est utilisé pour les cartes AMD dans le cadre de l'API CUDA).
+  3. **Intel oneAPI / XPU** : Si le système prend en charge **Intel oneAPI** ou **XPU** via `torch.xpu.is_available()`, le périphérique sera défini sur **XPU**.
+  
+#### **Système non reconnu**
+- Si aucune des conditions ci-dessus n'est remplie, la fonction retourne `'CPU'` comme périphérique par défaut.
+
+---

{neuralnetworks-0.2.2.dist-info → neuralnetworks-0.2.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
-NeuralNetworks/__init__.py,sha256=AWRytyL2O4sZQetW9JB1XqmWtJMK1X9b50Z7WMLD1nY,798
+NeuralNetworks/__init__.py,sha256=fheTarkDt5IAOzXWTYDY9Jt9jg4heUVbIQ6H7RgwrCc,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=cEW_M5lZPiuozlItNIAYGhJ_NauwUnhGurcY4r_gh-A,3067
+NeuralNetworks/MLP/__init__.py,sha256=Q9VvDPArSbxP1Idrog7FWh-qba3rDoVl_K6kw9sSnvk,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
@@ -13,12 +13,8 @@ NeuralNetworks/Trainer/train.py,sha256=NAbHFKg4hl96OXq_i63lcRYwrPHiuKu7ihexakhpg
 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/tools/AirfRANS.py,sha256=UaCT3cuMz4_SPtgk9a7ZGB12l8dnDHjoAkD2ovLrAWk,1412
-NeuralNetworks/tools/MNIST.py,sha256=1lcB-dmlvpcxvQmjjHW2d5wR84uWB5rzYP6VC6CMoN4,4333
-NeuralNetworks/tools/VKI-LS59.py,sha256=OZqrJvR5QDcPEtuL7H0UoxpFwkjmWmOmfVWoV1d8fIs,354
-NeuralNetworks/tools/image.py,sha256=dtohmcOtGJ0rK3uXxy9O2zhhTE_DZDoZKmUSnBNkv0Q,8952
-neuralnetworks-0.2.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-neuralnetworks-0.2.2.dist-info/METADATA,sha256=x5PCHM2idxDoVvJBqOfH21bzNZbhwwojuPPEuStgQb0,15176
-neuralnetworks-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuralnetworks-0.2.2.dist-info/top_level.txt,sha256=h18nmC1BX7avyAAwKh0OQWezxgXmOpmVtbFq-8Mcbms,15
-neuralnetworks-0.2.2.dist-info/RECORD,,
+neuralnetworks-0.2.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+neuralnetworks-0.2.3.dist-info/METADATA,sha256=NBOkoMO48dNjlelcIFSt5n7MAQ6wFCVHjcLZNoBZmvw,17339
+neuralnetworks-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuralnetworks-0.2.3.dist-info/top_level.txt,sha256=h18nmC1BX7avyAAwKh0OQWezxgXmOpmVtbFq-8Mcbms,15
+neuralnetworks-0.2.3.dist-info/RECORD,,

NeuralNetworks/tools/AirfRANS.py

@@ -1,36 +0,0 @@
-# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fourier
-# Copyright (C) 2025 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 airfrans import *
-
-def download(path,unzip = True, OpenFOAM = False):
-    """
-    Télécharge le dataset AirfRANS dans le dossier spécifié.
-
-    Cette fonction est un simple wrapper autour :
-        dataset.download(root=path, file_name='AirfRANS', unzip=True, OpenFOAM=True)
-
-    Les arguments `unzip` et `OpenFOAM` sont actuellement ignorés par la fonction
-    et forcés à True dans l’appel interne.
-
-    Parameters
-    ----------
-    path : str
-        Chemin du dossier dans lequel le dataset doit être téléchargé.
-    unzip : bool, optional
-        Paramètre non utilisé. Le téléchargement interne force `unzip=True`.
-    OpenFOAM : bool, optional
-        Paramètre non utilisé. Le téléchargement interne force `OpenFOAM=True`.
-
-    Notes
-    -----
-    - Le fichier téléchargé s’appelle `'AirfRANS'`.
-    - Le dataset est automatiquement décompressé.
-    - Le format OpenFOAM est toujours inclus.
-    """
-    dataset.download(root = path, file_name = 'AirfRANS', unzip = True, OpenFOAM = True)

NeuralNetworks/tools/MNIST.py

@@ -1,118 +0,0 @@
-# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fourier
-# Copyright (C) 2025 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 torchvision.datasets import MNIST
-
-def data(path):
-    """
-    Charge le dataset MNIST depuis `path`, applique une transformation en tenseur,
-    puis convertit les images en vecteurs numpy aplatis et les labels en tenseur PyTorch.
-
-    Parameters
-    ----------
-    path : str
-        Chemin du dossier où MNIST sera téléchargé ou chargé.
-
-    Returns
-    -------
-    inputs : np.ndarray
-        Tableau numpy de shape (N, 784) contenant les images MNIST aplaties.
-        Chaque pixel est normalisé dans [0, 1] via `ToTensor()`.
-    outputs : torch.Tensor
-        Tenseur PyTorch de shape (N, 1) contenant les labels entiers (0–9).
-
-    Notes
-    -----
-    - Le dataset MNIST est téléchargé si absent.
-    - Chaque image 28×28 est convertie via `ToTensor()` puis aplatie en vecteur de 784 valeurs.
-    - Les labels sont convertis en tenseur long et remis dans une dimension (N, 1)
-      pour compatibilité avec un MLP produisant une sortie scalaire.
-    """
-    transform = Compose([ToTensor()])
-    dataset = MNIST(path, transform=transform, download=True)
-    
-    inputs, outputs = [], []
-    for data in dataset:
-        outputs.append(data[1])
-        value= data[0].numpy().flatten()
-        inputs.append(value)
-    outputs = torch.tensor(np.array(outputs))   # convert list → tensor
-    outputs = outputs.unsqueeze(1) 
-    inputs = np.array(inputs)
-
-    return inputs, outputs
-
-def evaluate (inputs, *nets):
-    """
-    Évalue visuellement un ou plusieurs réseaux sur un échantillon MNIST choisi
-    aléatoirement. La fonction affiche simultanément :
-
-        - l'image d'entrée (28×28),
-        - les courbes de perte de chaque réseau (échelle logarithmique),
-        - la prédiction de chaque réseau imprimée dans la console.
-
-    Parameters
-    ----------
-    inputs : np.ndarray
-        Tableau numpy contenant les images aplaties (N, 784).
-        Une image sera choisie aléatoirement parmi celles-ci.
-    nets : MLP
-        Un ou plusieurs réseaux entraînés, chacun possédant :
-        - net.losses : liste des pertes par époque,
-        - net.name   : nom du modèle,
-        - net(x)     : méthode d'inférence retournant une valeur prédite.
-
-    Notes
-    -----
-    - L'image affichée est l'entrée sélectionnée, remise en forme en 28×28.
-    - Les pertes sont tracées pour chaque réseau sur une échelle Y logarithmique.
-    - Les prédictions sont arrondies et converties en entiers pour un affichage clair.
-    - Une figure matplotlib avec deux sous-graphiques est générée via GridSpec :
-        * à gauche  : l'image MNIST,
-        * à droite : les courbes de pertes.
-    - Les résultats (prédictions) sont également affichés dans la console.
-    """
-
-    # --- Configuration de la grille de figure ---
-    fig = plt.figure(figsize=(10, 5))
-    gs = GridSpec(1, 2, figure=fig)
-
-    index = np.random.randint(0,len(inputs)-1)
-
-    # --- Préparation du subplot pour les courbes de pertes ---
-    ax_loss = fig.add_subplot(gs[0, 1])
-    ax_loss.set_yscale('log', nonpositive='mask')
-    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)
-    ax_loss.set_xlim(1, lenlosses)
-
-    preds = []
-    for k, net in enumerate(nets):
-        preds.append(int(np.round(net(inputs[index]))))
-        # Tracé des pertes cumulées
-        ax_loss.plot(np.arange(1, len(all_losses[k])+1), all_losses[k],label = net.name)
-    ax_loss.legend()
-
-    # --- Affichage de l'image originale ---
-    ax_orig = fig.add_subplot(gs[0, 0])
-    ax_orig.axis('off')
-    ax_orig.set_title("input")
-    show = inputs[index].reshape(28,28)
-    ax_orig.imshow(255*show)
-
-    # --- Affichage final ---
-    fig.canvas.draw_idle()
-    plt.tight_layout()
-    plt.ion()
-    plt.show()
-
-    for k in rglen(preds):
-        print(f"{nets[k].name} output : {preds[k]}")

NeuralNetworks/tools/VKI-LS59.py

@@ -1,7 +0,0 @@
-# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fourier
-# Copyright (C) 2025 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/tools/image.py

@@ -1,249 +0,0 @@
-# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fourier
-# Copyright (C) 2025 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 *
-
-def url(url, img_size=256):
-    """
-    Télécharge une image depuis une URL, la redimensionne et prépare les
-    données pour l'entraînement d'un MLP pixel-wise.
-
-    Cette fonction retourne :
-    - `img_array` : image RGB sous forme de tableau NumPy (H, W, 3), pour affichage.
-    - `inputs` : coordonnées normalisées (x, y) de chaque pixel, sous forme de tenseur (H*W, 2).
-    - `outputs` : valeurs RGB cibles pour chaque pixel, sous forme de tenseur (H*W, 3).
-
-    Paramètres
-    ----------
-    url : str
-        URL de l'image à télécharger.
-    img_size : int, optionnel
-        Taille finale carrée de l'image (img_size x img_size). Par défaut 256.
-
-    Retours
-    -------
-    img_array : numpy.ndarray of shape (H, W, 3)
-        Image sous forme de tableau NumPy, valeurs normalisées entre 0 et 1.
-    inputs : torch.Tensor of shape (H*W, 2)
-        Coordonnées normalisées des pixels pour l'entrée du MLP.
-    outputs : torch.Tensor of shape (H*W, 3)
-        Valeurs RGB cibles pour chaque pixel, pour la sortie du MLP.
-
-    Notes
-    -----
-    - La fonction utilise `PIL` pour le traitement de l'image et `torchvision.transforms`
-      pour la conversion en tenseur normalisé.
-    - Les coordonnées sont normalisées dans [0, 1] pour une utilisation optimale
-      avec des MLP utilisant Fourier Features ou activations standard.
-    - Les tenseurs `inputs` et `outputs` sont prêts à être envoyés sur GPU si nécessaire.
-    """
-
-    # --- Téléchargement et ouverture de l'image ---
-    response = requests.get(url)
-    img = Image.open(BytesIO(response.content)).convert("RGB")
-
-    # --- Redimensionnement et conversion en tenseur normalisé ---
-    transform = Compose([
-        Resize((img_size, img_size)),
-        ToTensor()  # Donne un tenseur (3, H, W) normalisé entre 0 et 1
-    ])
-    img_tensor = transform(img)
-
-    # Récupération de la hauteur et largeur
-    h, w = img_tensor.shape[1:]
-
-    # Conversion en tableau NumPy (H, W, 3) pour affichage
-    img_array = img_tensor.permute(1, 2, 0).numpy()
-
-    # --- Création d'une grille normalisée des coordonnées des pixels ---
-    x_coords = torch.linspace(0, 1, w)
-    y_coords = torch.linspace(0, 1, h)
-    x_grid, y_grid = torch.meshgrid(x_coords, y_coords, indexing="ij")
-
-    # Flatten de la grille pour former les entrées du MLP : shape (H*W, 2)
-    inputs = torch.stack([x_grid.flatten(), y_grid.flatten()], dim=-1)
-
-    # Extraction des valeurs RGB comme sorties cibles : shape (H*W, 3)
-    outputs = img_tensor.view(3, -1).permute(1, 0)
-
-    return img_array, inputs, outputs
-url.help = fPrintDoc(url)
-
-def reshape(img_array, array):
-    """
-    Reshape un tenseur plat de prédiction en image (H, W, 3) en utilisant
-    les dimensions de l’image originale.
-
-    Parameters
-    ----------
-    img_array : np.ndarray of shape (H, W, 3)
-        Image originale servant de référence pour récupérer la hauteur (H)
-        et la largeur (W).
-    array : tensor-like or ndarray of shape (H*W, 3)
-        Tableau plat contenant les valeurs RGB prédites pour chaque pixel.
-
-    Returns
-    -------
-    np.ndarray of shape (H, W, 3)
-        Image reconstruite à partir du tableau plat.
-
-    Notes
-    -----
-    - Cette fonction ne modifie pas les valeurs, elle fait uniquement un reshape.
-    - Utile après une prédiction de type MLP qui renvoie un tableau (N, 3).
-    """
-
-    # Récupération de la hauteur et largeur à partir de l’image originale
-    h, w = img_array.shape[:2]
-
-    # Reconstruction en image RGB
-    return array.reshape(h, w, 3)
-reshape.help = fPrintDoc(reshape)
-
-def compare(img_array, inputs, *nets):
-    """
-    Affiche, pour chaque réseau, l’erreur absolue entre l’image originale
-    et l’image reconstruite par le réseau.
-
-    Chaque réseau doit posséder :
-    - une méthode `encoding(x)` (si RFF activé),
-    - un module `model` retournant un tenseur de shape (N, 3),
-    - une reconstruction compatible avec (H, W, 3).
-
-    Parameters
-    ----------
-    img_array : np.ndarray of shape (H, W, 3)
-        Image originale servant de référence.
-    inputs : tensor-like of shape (H*W, 2)
-        Coordonnées normalisées des pixels correspondant à chaque point de l'image.
-    *nets : *MLP
-        Un ou plusieurs réseaux.
-
-    Notes
-    -----
-    - L’affichage montre la différence absolue entre l’image originale et la prédiction du réseau.
-    - Les pertes cumulées sont également tracées pour chaque réseau.
-    - Utilise matplotlib en mode interactif.
-    """
-
-    # --- Conversion des inputs en tensor et récupération du nombre d'échantillons ---
-    inputs, n_samples = tensorise(inputs), inputs.size(0)
-    h, w = img_array.shape[:2]
-
-    # --- Configuration de la grille de figure ---
-    grid_length = 2 if len(nets) == 1 else len(nets)
-    fig = plt.figure(figsize=(5*grid_length, 10))
-    gs = GridSpec(2, grid_length, figure=fig)
-
-    # --- Affichage de l'image originale ---
-    ax_orig = fig.add_subplot(gs[0, 0])
-    ax_orig.axis('off')
-    ax_orig.set_title("Original Image")
-    ax_orig.imshow(img_array)
-
-    # --- Préparation du subplot pour les courbes de pertes ---
-    ax_loss = fig.add_subplot(gs[0, 1])
-    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)
-    ax_loss.set_xlim(1, lenlosses)
-    ax_loss.set_yscale('log', nonpositive='mask')
-    
-
-    # --- Boucle sur chaque réseau pour afficher l'erreur et les pertes ---
-    for k, net in enumerate(nets):
-        # Subplot pour l'erreur absolue
-        ax = fig.add_subplot(gs[1, k])
-        ax.axis('off')
-        ax.set_title(net.name)
-
-        # Prédiction et reconstruction de l'image
-        pred_img = net(inputs).reshape(h, w, 3)
-
-        # Tracé des pertes cumulées
-        ax_loss.plot(np.arange(1, len(all_losses[k])+1), all_losses[k],label = net.name)
-
-        # Affichage de l'erreur absolue
-        ax.imshow(np.abs(img_array - pred_img))
-    ax_loss.legend()
-    
-    # --- Affichage final ---
-    fig.canvas.draw_idle()
-    plt.tight_layout()
-    plt.ion()
-    plt.show()
-compare.help = fPrintDoc(compare)
-
-def plot(img_array, inputs, *nets):
-    """
-    Affiche, pour chaque réseau, l’image reconstruite à partir de ses prédictions.
-
-    Parameters
-    ----------
-    img_array : np.ndarray of shape (H, W, 3)
-        Image originale, utilisée pour connaître les dimensions de reconstruction.
-    inputs : tensor-like of shape (H*W, 2)
-        Coordonnées normalisées des pixels correspondant à chaque point de l'image.
-    *nets : *MLP
-        Un ou plusieurs réseaux.
-    Notes
-    -----
-    - Cette fonction affiche la prédiction brute.
-    - Les pertes cumulées sont également tracées pour chaque réseau.
-    - Utilise matplotlib en mode interactif.
-    """
-
-    # --- Conversion des inputs en tensor et récupération du nombre d'échantillons ---
-    inputs, n_samples = tensorise(inputs), inputs.size(0)
-    h, w = img_array.shape[:2]
-
-    # --- Configuration de la grille de figure ---
-    grid_length = 2 if len(nets) == 1 else len(nets)
-    fig = plt.figure(figsize=(5*grid_length, 10))
-    gs = GridSpec(2, grid_length, figure=fig)
-
-    # --- Affichage de l'image originale ---
-    ax_orig = fig.add_subplot(gs[0, 0])
-    ax_orig.axis('off')
-    ax_orig.set_title("Original Image")
-    ax_orig.imshow(img_array)
-
-    # --- Préparation du subplot pour les courbes de pertes ---
-    ax_loss = fig.add_subplot(gs[0, 1])
-    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)
-    ax_loss.set_xlim(1, lenlosses)
-
-    # --- Boucle sur chaque réseau pour afficher les prédictions et pertes ---
-    for k, net in enumerate(nets):
-        # Subplot pour l'image reconstruite
-        ax = fig.add_subplot(gs[1, k])
-        ax.axis('off')
-        ax.set_title(net.name)
-
-        # Prédiction et reconstruction de l'image
-        pred_img = net(inputs).reshape(h, w, 3)
-
-        # Tracé des pertes cumulées
-        ax_loss.plot(np.arange(1, len(all_losses[k])+1), all_losses[k],label = net.name)
-        ax_loss.set_yscale('log', nonpositive='mask')
-    
-        # Affichage de l'image prédite
-        ax.imshow(pred_img)
-    ax_loss.legend()
-
-    # --- Affichage final ---
-    fig.canvas.draw_idle()
-    plt.tight_layout()
-    plt.ion()
-    plt.show()
-plot.help = fPrintDoc(plot)

neuralnetworks-0.2.2.dist-info/METADATA

@@ -1,194 +0,0 @@
-Metadata-Version: 2.4
-Name: NeuralNetworks
-Version: 0.2.2
-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
-Project-URL: Documentation, https://xxxfetraxxx.github.io/NeuralNetworks/
-Project-URL: Source, https://github.com/xXxFetraxXx/NeuralNetworks
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-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
-Dynamic: license-file
-
-# NeuralNetworks Module
-
-Module complet pour la création, l'entraînement et la visualisation de Multi-Layer Perceptrons (MLP)  
-avec encodage optionnel Fourier, gestion automatique des pertes, compilation Torch et outils  
-de traitement d'images pour l'apprentissage sur des images RGB.
-
----
-
-## Contenu principal
-
-### Classes
-
-#### `MLP`
-
-Multi-Layer Perceptron (MLP) avec encodage optionnel Fourier (RFF),  
-suivi automatique des pertes, visualisation et compilation PyTorch.
-
-Cette classe fournit :
-
-- Un MLP entièrement configurable (dimensions, normalisation, activation)  
-- Option d'encodage Fourier (Random Fourier Features) sur les entrées  
-- Méthodes pour entraîner le réseau avec mini-batchs et AMP (Automatic Mixed Precision)  
-- Visualisation de l'architecture via visualtorch  
-- Suivi et affichage de la perte d'entraînement  
-- Accès aux poids, biais et nombre de paramètres  
-
----
-
-##### Parameters
-
-| Parameter            | Type          | Optional | Description                                                                                   |
-|----------------------|---------------|----------|-----------------------------------------------------------------------------------------------|
-| `input_size`         | int           | Yes      | Taille des données en entrée au réseau. Default: `1`                                   |
-| `output_size`        | int           | Yes      | Taille des données en sortie au réseau. Default: `1`                                   |
-| `hidden_layers`      | list[int]     | Yes      | Dimensions successives des couches intermédiaires du réseau. Default: `[1]`                   |
-| `sigmas`             | list[float]   | Yes      | Liste de sigma pour encodages RFF. Si None : passthrough. Default: `None`                     |
-| `fourier_input_size` | int           | Yes      | WIP. Default: `2`                                                                             |
-| `nb_fourier`         | int           | Yes      | Nombre de fréquences utilisées pour les Fourier Features. Default: `8`                        |
-| `norm`               | str           | Yes      | Type de normalisation / activation pour les couches cachées (ex: `"Relu"`). Default: `"Relu"` |
-| `name`               | str           | Yes      | Nom du réseau pour identification ou affichage. Default: `"Net"`                              |
-
----
-
-##### Attributes
-
-- `losses : list[float]` — Historique des pertes cumulées lors de l'entraînement  
-- `learnings : list[float]` — Historique des taux d'apprentissage utilisées lors de l'entraînement  
-- `model : nn.Sequential` — MLP complet construit dynamiquement 
-- `name : str` — Nom du réseau
-
----
-
-#### `Trainer`
-
----
-
-##### Parameters
-
-| Parameter    | Type            | Optional | Description                                                                                                     |
-|--------------|-----------------|----------|-----------------------------------------------------------------------------------------------------------------|
-| `*nets`      | *MLP            | No       | Réseaux pour lesquels le trainer va entrainer.                                                                  |
-| `inputs`     | np.array(float) | No       | Données en entrée au réseau.                                                                                    |
-| `outputs`    | np.array(float) | No       | Données en sortie au réseau.                                                                                    |
-| `test_size`  | float           | Yes      | Proportion des données à utiliser pendant l'entrainement. Si None : utilise toutes les données. Default: `None` |
-| `optim`      | str             | Yes      | Nom de l’optimiseur à utiliser (doit exister dans `optims()`). Default: `"Adam"`                                |
-| `init_lr`    | float           | Yes      | Taux d’apprentissage initial pour l’optimiseur. Default: `1e-3`                                                 |
-| `crit`       | str             | Yes      | Fonction de perte à utiliser (doit exister dans `crits()`). Default: `"MSE"`                                    |
-| `batch_size` | float           | Yes      | Taille des minibatchs. Default: `1024`                                                                          |
-
----
-
-##### `Trainer.train`
-
-Lancement d'un entrainement avec le trainer définit
-
-| Parameter       | Type    | Optional | Description                             |
-|-----------------|---------|----------|-----------------------------------------|
-| `num_epochs`    | int     | Yes      | Nombres d'itérations à effectuer.       |
-| `activate_tqdm` | boolean | Yes      | Utilisation d'une barre de progression. |
-  
----
-
-### Dictionnaires
-
-#### `norms()`
-
-| **Valeurs**         | **Module PyTorch**                                                                         | **Description**                                                                                           |
-|---------------------|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
-| **"ReLU"**          | [`nn.ReLU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.ReLU.html)           | Fonction d'activation ReLU classique (Rectified Linear Unit).                                             |
-| **"LeakyReLU"**     | [`nn.LeakyReLU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.LeakyReLU.html) | ReLU avec un petit coefficient pour les valeurs négatives (paramètre `negative_slope`).                   |
-| **"ELU"**           | [`nn.ELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.ELU.html)             | Fonction d'activation ELU (Exponential Linear Unit), qui a une meilleure gestion des valeurs négatives.   |
-| **"SELU"**          | [`nn.SELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.SELU.html)           | SELU (Scaled Exponential Linear Unit), une version améliorée de l'ELU pour des réseaux auto-normalisants. |
-| **"GELU"**          | [`nn.GELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.GELU.html)           | GELU (Gaussian Error Linear Unit), une activation probabiliste basée sur une fonction gaussienne.         |
-| **"Mish"**          | [`nn.Mish()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Mish.html)           | ReLU différentiable en tout points avec passage négatif.                                                  |
-| **"Softplus"**      | [`nn.Softplus()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Softplus.html)   | Fonction d'activation qui approxime ReLU mais de manière lissée.                                          |
-| **"Sigmoid"**       | [`nn.Sigmoid()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Sigmoid.html)     | Fonction d'activation Sigmoid, qui produit une sortie entre 0 et 1.                                       |
-| **"Tanh"**          | [`nn.Tanh()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Tanh.html)           | Fonction d'activation Tanh, avec une sortie dans l'intervalle [-1, 1].                                    |
-| **"Hardtanh"**      | [`nn.Hardtanh()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Hardtanh.html)   | Variante de Tanh, avec des sorties limitées entre une plage spécifiée.                                    |
-| **"Softsign"**      | [`nn.Softsign()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Softsign.html)   | Fonction d'activation similaire à Tanh mais plus souple, avec des valeurs dans [-1, 1].                   |
-
----
-
-#### `crits()`
-
-| **Valeurs**                    | **Module PyTorch**                  | **Description**                                                                                                            |
-|--------------------------------|-------------------------------------|----------------------------------------------------------------------------------------------------------------------------|
-| **"MSE"**                      | [`nn.MSELoss`](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html) | Mean Squared Error Loss, utilisée pour les régressions.                        |
-| **"L1"**                       | `nn.L1Loss()`                       | L1 Loss (erreur absolue), souvent utilisée pour la régularisation.                                                         |
-| **"SmoothL1"**                 | `nn.SmoothL1Loss()`                 | Smooth L1 Loss, une combinaison de L1 et de MSE, moins sensible aux outliers.                                              |
-| **"Huber"**                    | `nn.HuberLoss()`                    | Fonction de perte Huber, une version lissée de L1 et MSE, moins affectée par les grands écarts.                            |
-| **"CrossEntropy"**             | `nn.CrossEntropyLoss()`             | Perte de Cross-Entropy, utilisée pour les problèmes de classification multi-classes.                                       |
-| **"KLDiv"**                    | `nn.KLDivLoss()`                    | Perte de divergence de Kullback-Leibler, souvent utilisée pour des modèles probabilistes.                                  |
-| **"PoissonNLL"**               | `nn.PoissonNLLLoss()`               | Perte de log-vraisemblance pour une distribution de Poisson, utilisée pour la modélisation de comptages.                   |
-| **"MultiLabelSoftMargin"**     | `nn.MultiLabelSoftMarginLoss()`     | Perte utilisée pour les problèmes de classification multi-étiquettes.                                                      |
-
----
-
-#### `optims()`
-
-| **Valeurs**         | **Module PyTorch**                   | **Description**                                                                                                                    |
-|---------------------|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------|
-| **"Adadelta"**      | `optim.Adadelta()`                   | Optimiseur Adadelta, basé sur les gradients adaptatifs, sans nécessité de réglage du taux d'apprentissage.                         |
-| **"Adafactor"**     | `optim.Adafactor()`                  | Optimiseur Adafactor, variant d'Adam avec une mise à jour plus efficace de la mémoire pour de grands modèles.                      |
-| **"Adam"**          | `optim.Adam()`                       | Optimiseur Adam, utilisant un gradient stochastique adaptatif avec des moyennes mobiles des gradients et des carrés des gradients. |
-| **"AdamW"**         | `optim.AdamW()`                      | Optimiseur Adam avec une régularisation L2 (weight decay) distincte, plus efficace que `Adam` avec `weight_decay`.                 |
-| **"Adamax"**        | `optim.Adamax()`                     | Version d'Adam utilisant une norme infinie pour les gradients, plus stable pour certaines configurations.                          |
-| **"ASGD"**          | `optim.ASGD()`                       | Optimiseur ASGD (Averaged Stochastic Gradient Descent), utilisé pour de grandes données avec une moyenne des gradients.            |
-| **"NAdam"**         | `optim.NAdam()`                      | Optimiseur NAdam, une version améliorée d'Adam avec une adaptation des moments de second ordre.                                    |
-| **"RAdam"**         | `optim.RAdam()`                      | Optimiseur RAdam, une version robuste de l'Adam qui ajuste dynamiquement les moments pour stabiliser l'entraînement.               |
-| **"RMSprop"**       | `optim.RMSprop()`                    | Optimiseur RMSprop, utilisant une moyenne mobile des carrés des gradients pour réduire les oscillations.                           |
-| **"Rprop"**         | `optim.Rprop()`                      | Optimiseur Rprop, basé sur les mises à jour des poids indépendantes des gradients.                                                 |
-| **"SGD"**           | `optim.SGD()`                        | Descente de gradient stochastique classique, souvent utilisée avec un taux d'apprentissage constant ou ajusté.                     |
-
----
-
-### `device`
-
-variable principale d'allocation des performances
-
-#### **Apple Silicon (macOS)**
-- Si le système d'exploitation est macOS (nommé `darwin` dans `platform.system()`), la fonction vérifie si l'accélérateur **Metal Performance Shaders** (MPS) est disponible sur l'appareil.
-  - Si MPS est disponible (`torch.backends.mps.is_available()`), l'appareil cible sera défini sur **MPS** (c'est un équivalent de CUDA pour les appareils Apple Silicon).
-  
-#### **Windows**
-- Si le système d'exploitation est Windows, la fonction vérifie d'abord si **CUDA** (NVIDIA) est disponible avec `torch.cuda.is_available()`. Si c'est le cas, le périphérique sera défini sur **CUDA**.
-  
-#### **Linux**
-- Si le système d'exploitation est Linux, plusieurs vérifications sont effectuées :
-  1. **CUDA** (NVIDIA) : Si `torch.cuda.is_available()` renvoie `True`, le périphérique sera défini sur **CUDA**.
-  2. **ROCm** (AMD) : Si le système supporte **ROCm** via `torch.backends.hip.is_available()`, l'appareil sera défini sur **CUDA** (ROCm est utilisé pour les cartes AMD dans le cadre de l'API CUDA).
-  3. **Intel oneAPI / XPU** : Si le système prend en charge **Intel oneAPI** ou **XPU** via `torch.xpu.is_available()`, le périphérique sera défini sur **XPU**.
-  
-#### **Système non reconnu**
-- Si aucune des conditions ci-dessus n'est remplie, la fonction retourne **CPU** comme périphérique par défaut.
-
----
-
-### Paramètres matplotlib et PyTorch
-
-- Style global pour fond transparent et texte gris  
-- Optimisations CUDA activées pour TF32, matmul et convolutions  
-- Autograd configuré pour privilégier les performances
-
----