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

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)

{neuralnetworks-0.1.12.dist-info → neuralnetworks-0.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: NeuralNetworks
-Version: 0.1.12
-Summary: Multi-Layer Perceptrons with Fourier encoding, visualization and PyTorch compilation
+Version: 0.2.0
+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/
@@ -23,6 +23,9 @@ 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

neuralnetworks-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+NeuralNetworks/Dependances.py,sha256=gtuEuktxDL9fHwPET58k2vGSqWJd7AAZCHW4DPHyc18,8508
+NeuralNetworks/Latent.py,sha256=JjHncjlNOuEiwJTv5T8LgqUDCCKJzF5bIrUMPWK6QE8,1867
+NeuralNetworks/MLP.py,sha256=3jz7mZ9U0WrQArY8djohElBtt_a-erRrH82iXmK0skU,23754
+NeuralNetworks/__init__.py,sha256=YL7m1LcHGp3R_WNLLPyG2H76M81VMpBeF0B705EuXHg,4664
+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.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+neuralnetworks-0.2.0.dist-info/METADATA,sha256=Z9dEBzq3NrcLlY68ggbCH7Pei7GwijVRfKWR_nK4QqE,12070
+neuralnetworks-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuralnetworks-0.2.0.dist-info/top_level.txt,sha256=h18nmC1BX7avyAAwKh0OQWezxgXmOpmVtbFq-8Mcbms,15
+neuralnetworks-0.2.0.dist-info/RECORD,,

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)