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

NeuralNetworks/UI/Learnings.py

@@ -0,0 +1,45 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from ..Dependances import plt, np
+
+def learnings(*nets):
+
+    # --- Initialisation de la figure ---
+    fig, ax1 = plt.subplots()
+    fig.set_figheight(5)
+    fig.set_figwidth(5)
+
+    # --- Définition des limites des axes ---
+    all_learnings = [[lr for lr in net.learnings] for net in nets]
+    if max(len(lst) for lst in all_learnings) == 1:
+        lenlearnings = 2
+    else:
+        lenlearnings = max(len(lst) for lst in all_learnings)
+    plt.xlim(1, lenlearnings)
+
+    # --- Tracé des courbes de pertes pour chaque réseau ---
+    for k, net in enumerate(nets):
+        ax1.plot(
+            np.arange(1, len(all_learnings[k]) + 1),
+            all_learnings[k],
+            label=net.name
+        )
+    ax1.set_xlabel("Epochs")
+    ax1.set_ylabel("Learning rate")
+    ax1.legend(loc="upper left")
+    ax1.grid(True)
+    
+    plt.yscale('log', nonpositive='mask')
+    # --- Affichage ---
+    plt.legend()
+    plt.xlabel("Epoch")
+    plt.ylabel("Learning rate")
+    fig.canvas.draw_idle()
+    plt.tight_layout()
+    plt.ion()  # mode interactif
+    plt.show()

NeuralNetworks/UI/Losses.py

@@ -0,0 +1,45 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from ..Dependances import plt, np
+
+def losses(*nets):
+
+    # --- Initialisation de la figure ---
+    fig, ax1 = plt.subplots()
+    fig.set_figheight(5)
+    fig.set_figwidth(5)
+
+    # --- Définition des limites des axes ---
+    all_losses = [[loss for loss in net.losses] for net in nets]
+    if max(len(lst) for lst in all_losses) == 1:
+        lenlosses = 2
+    else:
+        lenlosses = max(len(lst) for lst in all_losses)
+    plt.xlim(1, lenlosses)
+
+    # --- Tracé des courbes de pertes pour chaque réseau ---
+    for k, net in enumerate(nets):
+        ax1.plot(
+            np.arange(1, len(all_losses[k]) + 1),
+            all_losses[k],
+            label=net.name
+        )
+    ax1.set_xlabel("Epochs")
+    ax1.set_ylabel("Loss")
+    ax1.legend(loc="upper left")
+    ax1.grid(True)
+    
+    plt.yscale('log', nonpositive='mask')
+    # --- Affichage ---
+    plt.legend()
+    plt.xlabel("Epoch")
+    plt.ylabel("Résidus")
+    fig.canvas.draw_idle()
+    plt.tight_layout()
+    plt.ion()  # mode interactif
+    plt.show()

NeuralNetworks/UI/__init__.py

@@ -0,0 +1,9 @@
+# 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 .Losses import losses
+from .Learnings import learnings

NeuralNetworks/__init__.py

@@ -1,128 +1,23 @@
-# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fourier
-# Copyright (C) 2025 Alexandre Brun
+# 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.
 
-"""
-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 options avancées :
-   - 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.
-
-   Méthodes principales :
-   - __init__(layers, learning_rate, Fourier, optimizer, criterion, normalizer, name, Iscompiled)
-     Initialise le réseau avec toutes les options.
-   - train(inputs, outputs, num_epochs, batch_size)
-     Entraîne le MLP sur des données (inputs → outputs) en utilisant AMP et mini-batchs.
-   - plot(inputs, img_array)
-     Affiche l'image originale, la prédiction du MLP et la courbe des pertes.
-   - __call__(x)
-     Applique l’encodage puis le MLP pour produire une prédiction.
-   - Create_MLP(layers)
-     Construit le MLP avec normalisation/activation et Sigmoid finale.
-   - 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.
-   - neurons()
-     Retourne la liste des biais (neurones) de toutes les couches linéaires.
-   - __repr__()
-     Affiche un schéma visuel du MLP via visualtorch et print des dimensions.
-
-Fonctions utilitaires
---------------------
-
-tensorise(obj)
-   Convertit un objet array-like ou tensor en torch.Tensor float32 sur le device actif.
-
-list_to_cpu(cuda_tensors)
-   Copie une liste de tenseurs CUDA et les transfère sur le CPU.
-
-rglen(list)
-   Renvoie un range correspondant aux indices d'une liste.
-
-fPrintDoc(obj)
-   Crée une fonction lambda qui affiche le docstring d'un objet.
-
-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.
-
-Visualisation et comparaison
-----------------------------
-
-plot(img_array, inputs, *nets)
-   Affiche pour chaque réseau l'image reconstruite à partir des entrées.
-
-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 :
-   - encoding(x) si RFF activé
-   - model() retournant un tenseur (N, 3)
-   - attribute losses
-
-Objets et dictionnaires
------------------------
-
-Norm_list : dict
-   Contient les modules PyTorch correspondant aux fonctions de normalisation/activation
-   disponibles (ReLU, GELU, Sigmoid, Tanh, etc.)
-
-Criterion_list : dict
-   Contient les fonctions de perte PyTorch disponibles (MSE, L1, SmoothL1, BCE, CrossEntropy, etc.)
-
-Optim_list(self, learning_rate)
-   Retourne un dictionnaire d’optimiseurs PyTorch initialisés avec `self.model.parameters()`.
-
-Device et configuration
------------------------
-
-device
-   Device par défaut (GPU si disponible, sinon CPU).
+# Import des dépendances et utilitaires globaux (device, settings, tensorise, etc.)
+from .Dependances import norms, crits, optims, rglen, device, pi, e, tensorise
 
-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.
+# Modèle MLP principal + fonction d'entraînement associée
+from .MLP import MLP, losses
 
-Notes générales
----------------
+from .Trainer import Trainer
 
-- 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.
-"""
+from .UI import *
 
-# Import des dépendances et utilitaires globaux (device, settings, tensorise, etc.)
-from .Dependances import norms, crits, optims, rglen, device, pi, e, tensorise
+from .Latent import Latent
 
 # Fonctions de chargement/preprocessing des images
-from .Image import image_from_url
-
-# Fonctions d'affichage : reconstruction, comparaison, courbes de pertes
-from .Plot import compare, plot, losses, train
-
-# Modèle MLP principal + fonction d'entraînement associée
-from .MLP import MLP
+from .tools import image, MNIST, AirfRANS
 
-__version__ = "0.1.12"
+__version__ = "0.2.2"

NeuralNetworks/tools/AirfRANS.py

@@ -0,0 +1,36 @@
+# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from ..Dependances import *
+from airfrans import *
+
+def download(path,unzip = True, OpenFOAM = False):
+    """
+    Télécharge le dataset AirfRANS dans le dossier spécifié.
+
+    Cette fonction est un simple wrapper autour :
+        dataset.download(root=path, file_name='AirfRANS', unzip=True, OpenFOAM=True)
+
+    Les arguments `unzip` et `OpenFOAM` sont actuellement ignorés par la fonction
+    et forcés à True dans l’appel interne.
+
+    Parameters
+    ----------
+    path : str
+        Chemin du dossier dans lequel le dataset doit être téléchargé.
+    unzip : bool, optional
+        Paramètre non utilisé. Le téléchargement interne force `unzip=True`.
+    OpenFOAM : bool, optional
+        Paramètre non utilisé. Le téléchargement interne force `OpenFOAM=True`.
+
+    Notes
+    -----
+    - Le fichier téléchargé s’appelle `'AirfRANS'`.
+    - Le dataset est automatiquement décompressé.
+    - Le format OpenFOAM est toujours inclus.
+    """
+    dataset.download(root = path, file_name = 'AirfRANS', unzip = True, OpenFOAM = True)

NeuralNetworks/tools/MNIST.py

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

NeuralNetworks/tools/VKI-LS59.py

@@ -0,0 +1,7 @@
+# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+

NeuralNetworks/tools/image.py

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