PyPI - NeuralNetworks - Versions diffs - 0.2.0__tar.gz → 0.2.2__tar.gz - Mend

NeuralNetworks 0.2.0tar.gz → 0.2.2tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

{neuralnetworks-0.2.0/src/NeuralNetworks.egg-info → neuralnetworks-0.2.2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NeuralNetworks
-Version: 0.2.0
+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
@@ -40,92 +40,101 @@ de traitement d'images pour l'apprentissage sur des images RGB.
 ### Classes
-#### MLP
+#### `MLP`
-Multi-Layer Perceptron (MLP) avec options avancées :
+Multi-Layer Perceptron (MLP) avec encodage optionnel Fourier (RFF),
+suivi automatique des pertes, visualisation et compilation PyTorch.
-- Encodage Fourier gaussien (RFF) optionnel
-- Stockage automatique des pertes
-- Compilation Torch optionnelle pour accélérer l’inférence
-- Gestion flexible de l’optimiseur, de la fonction de perte et de la normalisation
+Cette classe fournit :
-**Méthodes principales :**
+- 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
-- `MLP(layers, learning_rate, Fourier, optim, crit, norm, name, Iscompiled)`
-  Initialise le réseau avec toutes les options.
-  Les valeurs possibles de `optim`  sont disponibles avec `optims()`
-  Les valeurs possibles de `crit`  sont disponibles avec `crits()`
-  Les valeurs possibles de `norm`  sont disponibles avec `norms()`
+---
-- `train(inputs, outputs, num_epochs, batch_size)`
-  Entraîne le MLP sur des données (`inputs → outputs`) en utilisant AMP et mini-batchs.
+##### Parameters
-- `plot(inputs, img_array)`
-  Affiche l'image originale, la prédiction du MLP et la courbe des pertes.
+| 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"`                              |
-- `params()`
-  Retourne tous les poids du MLP (ligne par ligne) sous forme de liste de `numpy.ndarray`.
+---
-- `nb_params()`
-  Calcule le nombre total de poids dans le MLP.
+##### Attributes
-- `neurons()`
-  Retourne la liste des biais (neurones) de toutes les couches linéaires.
+- `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
 ---
-### Fonctions utilitaires
+#### `Trainer`
-- `tensorise(obj)`
-  Convertit un objet array-like ou tensor en `torch.Tensor` float32 sur le device actif.
+---
-- `rglen(list)`
-  Renvoie un range correspondant aux indices d'une liste.
+##### Parameters
-- `image_from_url(url, img_size)`
-  Télécharge une image depuis une URL, la redimensionne et génère :
-  - `img_array` : `np.ndarray (H, W, 3)` pour affichage.
-  - `inputs` : tenseur `(H*W, 2)` coordonnées normalisées.
-  - `outputs` : tenseur `(H*W, 3)` valeurs RGB cibles.
+| 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`                                                                          |
 ---
-### Visualisation et comparaison
-- `plot(img_array, inputs, *nets)`
-  Affiche pour chaque réseau l'image reconstruite à partir des entrées.
+##### `Trainer.train`
-- `compare(img_array, inputs, *nets)`
-  Affiche pour chaque réseau l'erreur absolue entre l'image originale et la prédiction,
-  et trace également les pertes cumulées. Chaque réseau doit posséder :
+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. |
 ---
-### Objets et dictionnaires
+### Dictionnaires
-#### **norms()**
+#### `norms()`
-| **Valeurs**         | **Module PyTorch**        | **Description**                                                                                           |
-|---------------------|---------------------------|-----------------------------------------------------------------------------------------------------------|
-| **"Relu"**          | `nn.ReLU()`               | Fonction d'activation ReLU classique (Rectified Linear Unit).                                             |
-| **"LeakyRelu"**     | `nn.LeakyReLU()`          | ReLU avec un petit coefficient pour les valeurs négatives (paramètre `negative_slope`).                   |
-| **"ELU"**           | `nn.ELU()`                | Fonction d'activation ELU (Exponential Linear Unit), qui a une meilleure gestion des valeurs négatives.   |
-| **"SELU"**          | `nn.SELU()`               | SELU (Scaled Exponential Linear Unit), une version améliorée de l'ELU pour des réseaux auto-normalisants. |
-| **"GELU"**          | `nn.GELU()`               | GELU (Gaussian Error Linear Unit), une activation probabiliste basée sur une fonction gaussienne.         |
-| **"Sigmoid"**       | `nn.Sigmoid()`            | Fonction d'activation Sigmoid, qui produit une sortie entre 0 et 1.                                       |
-| **"Tanh"**          | `nn.Tanh()`               | Fonction d'activation Tanh, avec une sortie dans l'intervalle [-1, 1].                                    |
-| **"Hardtanh"**      | `nn.Hardtanh()`           | Variante de Tanh, avec des sorties limitées entre une plage spécifiée.                                    |
-| **"Softplus"**      | `nn.Softplus()`           | Fonction d'activation qui approxime ReLU mais de manière lissée.                                          |
-| **"Softsign"**      | `nn.Softsign()`           | Fonction d'activation similaire à Tanh mais plus souple, avec des valeurs dans [-1, 1].                   |
+| **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()`                      | Mean Squared Error Loss, utilisée pour les régressions.                                                                    |
+| **"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.                            |
@@ -136,7 +145,7 @@ Multi-Layer Perceptron (MLP) avec options avancées :
 ---
-#### **optims()**
+#### `optims()`
 | **Valeurs**         | **Module PyTorch**                   | **Description**                                                                                                                    |
 |---------------------|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------|
@@ -154,7 +163,9 @@ Multi-Layer Perceptron (MLP) avec options avancées :
 ---
-### Device et configuration
+### `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.
@@ -181,10 +192,3 @@ Multi-Layer Perceptron (MLP) avec options avancées :
 - Autograd configuré pour privilégier les performances
 ---
-### Notes générales
-- Toutes les méthodes de MLP utilisent les tenseurs sur le device global (CPU ou GPU)
-- Les images doivent être normalisées entre 0 et 1
-- Les fonctions interactives (`plot`, `compare`) utilisent matplotlib en mode interactif
-- Le module est conçu pour fonctionner dans Jupyter et scripts Python classiques

neuralnetworks-0.2.2/README.md ADDED Viewed

@@ -0,0 +1,164 @@
+# 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
+---

neuralnetworks-0.2.2/src/NeuralNetworks/Dependances/__init__.py ADDED Viewed

@@ -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.2/src/NeuralNetworks/Dependances/matplot.py ADDED Viewed

@@ -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.2/src/NeuralNetworks/Dependances/pytorch.py ADDED Viewed

@@ -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.0__tar.gz → 0.2.2__tar.gz

NeuralNetworks 0.2.0tar.gz → 0.2.2tar.gz