NeuralNetworks 0.2.0__tar.gz → 0.2.3__tar.gz

neuralnetworks-0.2.3/PKG-INFO

@@ -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.3/README.md

@@ -0,0 +1,142 @@
+# 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.3/src/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-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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)