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

neuralnetworks-0.2.2.dist-info/METADATA

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

neuralnetworks-0.2.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+NeuralNetworks/__init__.py,sha256=AWRytyL2O4sZQetW9JB1XqmWtJMK1X9b50Z7WMLD1nY,798
+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/inference.py,sha256=9aL7pUx1LTVvrc6UYHX049UjODTgHY6cweFcp2gequQ,853
+NeuralNetworks/Trainer/__init__.py,sha256=v0qKqx9XkYWkuouNNy0jTHQ_cZqYhFj98qrwSXlDXy0,1711
+NeuralNetworks/Trainer/dynamic_learning_rate.py,sha256=1JAD-k0cjdL_71zGeeCUFOa61H4PzFITDjZ2nK0TzXU,2340
+NeuralNetworks/Trainer/sample_data.py,sha256=7waC9colb7DXU4yKMcgcCnPG3Guv-isipcgVHJPPCNE,673
+NeuralNetworks/Trainer/train.py,sha256=NAbHFKg4hl96OXq_i63lcRYwrPHiuKu7ihexakhpgDY,3182
+NeuralNetworks/UI/Learnings.py,sha256=4TBR5pcjyoBeL7eikNKM6xn25jnqL-mWT7hbrt9q-Gw,1418
+NeuralNetworks/UI/Losses.py,sha256=Tu5xuDiutR9a4xcZKpyWN_tzSDu3_fImEf8FbAEehio,1378
+NeuralNetworks/UI/__init__.py,sha256=L96xwQZJ-HoqqOGxaheosiDKHR3mRopuXkif--rO1J4,409
+NeuralNetworks/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/Dependances.py

@@ -1,319 +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.
-
-import numpy as np
-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
-
-import visualtorch
-
-from torchmetrics.image import PeakSignalNoiseRatio as PSNR
-from torchvision.transforms import ToTensor, Resize, Compose
-
-from PIL import Image
-
-import matplotlib.pyplot as plt
-from matplotlib.gridspec import GridSpec
-
-import platform
-import copy
-import math
-import subprocess
-import requests
-from io import BytesIO
-import rff
-from tqdm import tqdm
-
-from IPython.display import display, clear_output
-
-torch.cuda.empty_cache()
-
-# --- Device global ---
-# Utilise GPU si disponible, sinon CPU
-
-def get_best_device():
-    """
-    Détermine automatiquement le meilleur backend PyTorch disponible selon l'OS
-    et les GPU présents sur la machine.
-
-    La priorité dépend du système :
-
-    macOS (Apple Silicon)
-    ---------------------
-    - Utilise Metal/MPS si disponible.
-    - Sinon CPU.
-
-    Windows
-    -------
-    - CUDA si une GPU Nvidia CUDA est détectée.
-    - Sinon DirectML (AMD / Intel / Nvidia sans CUDA).
-    - Sinon CPU.
-
-    Linux
-    -----
-    - CUDA (Nvidia)
-    - ROCm (AMD)
-    - oneAPI / XPU (Intel GPU)
-    - Sinon CPU.
-
-    Retour
-    ------
-    torch.device
-        Le device optimal pour exécuter PyTorch selon le matériel détecté.
-
-    Notes
-    -----
-    - Sur ROCm, PyTorch expose l'alias "cuda", ce qui est normal.
-    - DirectML permet un fallback GPU universel sous Windows.
-    - Cette fonction ne lance aucun test de performance, elle se base uniquement
-      sur les backends disponibles dans l'installation PyTorch.
-    """
-
-    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()
-
-def has_gcc():
-    """Return True if GCC is installed and callable."""
-    try:
-        r = subprocess.run(
-            ["gcc", "--version"],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
-        )
-        return r.returncode == 0
-    except FileNotFoundError:
-        return False
-
-# --- Paramètres graphiques globaux ---
-# Fond transparent et couleur gris uniforme
-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
-
-# --- Optimisations CUDA ---
-# Accélération des convolutions et matmul
-torch.backends.cudnn.benchmark = True           # optimise selon les tailles de tenseurs
-torch.backends.cudnn.enabled = True
-torch.backends.cuda.matmul.allow_tf32 = True    # autorise TF32 (plus rapide sur Ampere+)
-torch.backends.cudnn.allow_tf32 = True
-
-# Paramètres autograd
-torch.autograd.set_detect_anomaly(False)        # pas d'analyse lourde
-torch.autograd.profiler.profile(enabled=False)
-torch.use_deterministic_algorithms(False)      # privilégie la performance à la reproductibilité stricte
-
-torch._inductor.config.max_autotune = "max"     # config max pour Torch-Inductor
-
-# Constantes
-pi = math.pi
-e = math.e
-
-# --- Liste des normalisations/activations disponibles ---
-norm_list = {
-    "Relu": nn.ReLU(),
-    "LeakyRelu": nn.LeakyReLU(),
-    "ELU": nn.ELU(),
-    "SELU": nn.SELU(),
-    "GELU": nn.GELU(),
-    "Sigmoid": nn.Sigmoid(),
-    "Tanh": nn.Tanh(),
-    "Hardtanh": nn.Hardtanh(),
-    "Softplus": nn.Softplus(),
-    "Softsign": nn.Softsign()
-}
-norms = lambda: print("""
-"Relu"
-"LeakyRelu"
-"ELU"
-"SELU"
-"GELU"
-"Sigmoid"
-"Tanh"
-"Hardtanh"
-"Softplus"
-"Softsign"
-"""
-)
-
-# --- Liste des fonctions de perte disponibles ---
-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(),
-}
-crits = lambda: print("""
-"MSE"
-"L1"
-"SmoothL1"
-"Huber"
-"CrossEntropy"
-"KLDiv"
-"PoissonNLL"
-"MultiLabelSoftMargin"
-"""
-)
-
-# --- Création d’un dictionnaire d’optimiseurs ---
-def optim_list(self, learning_rate):
-    """
-    Renvoie un dictionnaire d’optimiseurs PyTorch pour le MLP donné.
-
-    Paramètres
-    ----------
-    self : objet
-        Objet contenant `self.model` à optimiser.
-    learning_rate : float
-        Taux d’apprentissage à appliquer aux optimisateurs.
-
-    Retour
-    ------
-    dict
-        Dictionnaire {nom_optimiseur : instance_optimiseur}.
-    """
-    return {
-        "Adadelta": optim.Adadelta(self.model.parameters(), lr=learning_rate),
-        "Adafactor": optim.Adafactor(self.model.parameters(), lr=learning_rate),
-        "Adam": optim.Adam(self.model.parameters(), lr=learning_rate),
-        "AdamW": optim.AdamW(self.model.parameters(), lr=learning_rate),
-        "Adamax": optim.Adamax(self.model.parameters(), lr=learning_rate),
-        "ASGD": optim.ASGD(self.model.parameters(), lr=learning_rate),
-        "NAdam": optim.NAdam(self.model.parameters(), lr=learning_rate),
-        "RAdam": optim.RAdam(self.model.parameters(), lr=learning_rate),
-        "RMSprop": optim.RMSprop(self.model.parameters(), lr=learning_rate),
-        "Rprop": optim.Rprop(self.model.parameters(), lr=learning_rate),
-        "SGD": optim.SGD(self.model.parameters(), lr=learning_rate)
-    }
-
-optims = lambda: print("""
-"Adadelta"
-"Adafactor"
-"Adam"
-"AdamW"
-"Adamax"
-"ASGD"
-"NAdam"
-"RAdam"
-"RMSprop"
-"Rprop"
-"SGD"
-"""
-)
-
-# --- Fonctions utilitaires ---
-def rglen(list):
-    """
-    Renvoie un range correspondant aux indices d’une liste.
-
-    Paramètres
-    ----------
-    list : list-like
-        Objet dont on souhaite obtenir les indices.
-
-    Retour
-    ------
-    range
-        Range Python de 0 à len(list)-1.
-    """
-    return range(len(list))
-
-def tensorise(obj):
-    """
-    Convertit un objet en tenseur PyTorch float32 et l’envoie sur le device global.
-
-    Paramètres
-    ----------
-    obj : array-like, list, np.ndarray, torch.Tensor
-        Objet à convertir en tenseur.
-
-    Retour
-    ------
-    torch.Tensor
-        Tenseur float32 sur le device global (CPU ou GPU).
-
-    Notes
-    -----
-    - Harmonise les types pour MLP et autres traitements PyTorch.
-    - Assure que les données sont compatibles avec les opérations GPU/CPU.
-    """
-    return torch.as_tensor(obj, dtype=torch.float32, device=device)
-
-def fPrintDoc(obj):
-    """
-    Crée une fonction anonyme qui affiche le docstring d'un objet.
-
-    Paramètres
-    ----------
-    obj : object
-        Tout objet Python possédant un attribut `__doc__`.
-
-    Retour
-    ------
-    function
-        Une fonction sans argument. Lorsqu'on l'appelle, elle affiche
-        le docstring de l'objet passé.
-
-    Exemple
-    -------
-    >>> def ma_fonction():
-    ...     '''Ceci est le docstring.'''
-    ...     pass
-    >>> print_doc = fPrintDoc(ma_fonction)
-    >>> print_doc()
-    Ceci est le docstring.
-    """
-    return lambda: print(obj.__doc__)
-
-torch.cuda.empty_cache()

NeuralNetworks/Image.py

@@ -1,105 +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 image_from_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
-image_from_url.help = fPrintDoc(image_from_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)