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

NeuralNetworks/Plot.py

@@ -1,324 +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 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 possédant les méthodes `.encoding()` et `.model()`,
-        et l’attribut `.losses`.
-
-    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.item() 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_ylim(0, max(max(lst) for lst in all_losses))
-
-    # --- 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 = net.model(net.encoding(inputs))
-        pred_img = pred.reshape(h, w, 3).cpu().detach().numpy()
-
-        # Tracé des pertes cumulées
-        ax_loss.plot(np.arange(1, len(all_losses[k])+1), all_losses[k])
-
-        # Affichage de l'erreur absolue
-        ax.imshow(np.abs(img_array - pred_img))
-
-    # --- 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 possédant les méthodes `.encoding()` et `.model()`,
-        et l’attribut `.losses`.
-
-    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.item() 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_ylim(0, max(max(lst) for lst in all_losses))
-
-    # --- 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 = net.model(net.encoding(inputs))
-        pred_img = pred.reshape(h, w, 3).cpu().detach().numpy()
-
-        # 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 prédite
-        ax.imshow(pred_img)
-
-    # --- Affichage final ---
-    fig.canvas.draw_idle()
-    plt.tight_layout()
-    plt.ion()
-    plt.show()
-plot.help = fPrintDoc(plot)
-
-
-def losses(*nets):
-    """
-    Affiche les courbes de pertes (training loss) de plusieurs réseaux MLP.
-
-    Parameters
-    ----------
-    nets : MLP
-        Un ou plusieurs réseaux possédant un attribut `.losses`
-        contenant l'historique des pertes (liste de float).
-
-    Notes
-    -----
-    - L’axe X correspond aux itérations (epochs ou steps).
-    - L’axe Y correspond à la valeur de la perte.
-    - La fonction utilise matplotlib en mode interactif pour affichage dynamique.
-    """
-
-    # --- Initialisation de la figure ---
-    fig = plt.figure(figsize=(5, 5))
-
-    # --- Définition des limites des axes ---
-    all_losses = [[loss.item() 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)
-    plt.ylim(0, max(max(lst) for lst in all_losses))
-
-    # --- Tracé des courbes de pertes pour chaque réseau ---
-    for k, net in enumerate(nets):
-        steps = np.linspace(1, len(net.losses), len(net.losses))  # epochs
-        plt.plot(np.arange(1, len(all_losses[k])+1), all_losses[k],label = net.name)
-
-    # --- Affichage ---
-    plt.legend()
-    fig.canvas.draw_idle()
-    plt.tight_layout()
-    plt.ion()  # mode interactif
-    plt.show()
-losses.help = fPrintDoc(losses)
-
-def train(inputs, outputs, num_epochs=1500, batch_size=1024, *nets, img_array=None):
-    """
-    Entraîne un ou plusieurs MLP sur des paires (inputs, outputs) avec gestion optionnelle de l'affichage interactif.
-
-    Affiche dynamiquement si img_array est fourni :
-    - L'image originale (référence)
-    - Les prédictions des MLP
-    - L'évolution des pertes au fil des époques
-
-    Parameters
-    ----------
-    inputs : array-like
-        Entrées du ou des MLP (shape: [n_samples, n_features]).
-    outputs : array-like
-        Sorties cibles correspondantes (shape: [n_samples, output_dim]).
-    num_epochs : int, optional
-        Nombre d’époques pour l’entraînement (default=1500).
-    batch_size : int, optional
-        Taille des mini-batchs pour la descente de gradient (default=1024).
-    *nets : MLP
-        Un ou plusieurs objets MLP à entraîner.
-    img_array : np.ndarray of shape (H, W, 3), optional
-        Image de référence pour visualisation des prédictions (default=None).
-
-    Notes
-    -----
-    - Les MLP sont entraînés indépendamment mais avec le même ordre aléatoire d'échantillons.
-    - Utilise torch.amp.GradScaler pour l'entraînement en FP16.
-    - La visualisation interactive utilise clear_output() et plt.ion().
-    """
-
-    # --- Conversion des données en tensors et récupération du nombre d'échantillons ---
-    inputs, outputs, n_samples = tensorise(inputs).to(device), tensorise(outputs).to(device), inputs.size(0)
-    for net in nets:
-        net.model = net.model.to(device)
-    dev = str(device)
-    scaler = GradScaler(dev)
-    visual = False
-
-    # --- Initialisation de l'affichage interactif si une image de référence est fournie ---
-    if img_array is not None:
-        visual = True
-        h, w = img_array.shape[:2]
-        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)
-
-        # Image originale
-        ax_orig = fig.add_subplot(gs[0, 0])
-        ax_orig.axis('off')
-        ax_orig.set_title("Original Image")
-        im_orig = ax_orig.imshow(img_array)
-
-        # Images des prédictions initiales des MLP
-        ims_preds, axs_preds = [], []
-        for k, net in enumerate(nets):
-            ax = fig.add_subplot(gs[1, k])
-            ax.axis('off')
-            ax.set_title(f"Net {k+1}")
-            im = ax.imshow(net.model(net.encoding(inputs)).reshape(h, w, 3).cpu().detach().numpy())
-            ims_preds.append(im)
-            axs_preds.append(ax)
-
-        # Graphiques des pertes
-        ax_loss = fig.add_subplot(gs[0, 1])
-        lines = []
-        for k in range(len(nets)):
-            line, = ax_loss.plot([], [], label=f"Network {k+1}")
-            lines.append(line)
-        ax_loss.set_xlim(1)
-        ax_loss.set_ylim(0, 1)
-        ax_loss.set_xlabel("Epoch")
-        ax_loss.set_ylabel("Loss")
-        ax_loss.set_title("Loss per Epoch")
-        ax_loss.legend()
-        ax_loss.set_box_aspect(1)
-
-        fig.canvas.draw_idle()
-        plt.tight_layout()
-        plt.ion()
-        plt.show()
-
-    # --- Boucle principale d’entraînement ---
-    for epoch in tqdm(range(num_epochs), desc="train iter"):
-        perm = torch.randperm(n_samples, device=device)  # permutation aléatoire des indices
-        epoch_loss = [0.0 for _ in nets]  # stockage des pertes par MLP pour l'époque
-
-        # --- Mini-batchs ---
-        for k, net in enumerate(nets):
-            for i in range(0, n_samples, batch_size):
-                idx = perm[i:i+batch_size]
-
-                def closure():
-                    """Calcul de la loss et backpropagation pour un mini-batch."""
-                    net.optim.zero_grad(set_to_none=True)
-                    with autocast(dev):
-                        loss = net.crit(net.model(net.encoding(inputs[idx])), outputs[idx])
-                    scaler.scale(loss).backward()
-                    return loss
-
-                loss = closure()
-                scaler.step(net.optim)
-                scaler.update()
-                epoch_loss[k] += loss
-
-            # --- Stockage des pertes de l'époque ---
-            net.losses.append(epoch_loss[k])
-
-        # --- Mise à jour visuelle si mode interactif ---
-        if visual:
-            with torch.no_grad():
-                # Mise à jour des images prédictions
-                [im.set_data(nets[k](inputs).reshape(h, w, 3)) for k, im in enumerate(ims_preds)]
-                # Mise à jour des courbes de pertes
-                all_losses = [[loss.item() for loss in net.losses] for net in nets]
-                [line.set_data(np.arange(1, len(all_losses[k])+1), all_losses[k]) for k, line in enumerate(lines)]
-                ax_loss.set_xlim(1, max(len(lst) for lst in all_losses))
-                ax_loss.set_ylim(0, max(max(lst) for lst in all_losses))
-                clear_output(wait=True)
-                display(fig)
-
-    # --- Fin du mode interactif ---
-    if visual:
-        plt.ioff()
-train.help = fPrintDoc(train)

neuralnetworks-0.1.11.dist-info/METADATA

@@ -1,146 +0,0 @@
-Metadata-Version: 2.4
-Name: NeuralNetworks
-Version: 0.1.11
-Summary: Multi-Layer Perceptrons with Fourier encoding, 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
-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 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.
-
-- `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)`  
-  - attribut `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).
-
----
-
-### 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
-
----
-
-### 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.1.11.dist-info/RECORD

@@ -1,10 +0,0 @@
-NeuralNetworks/Dependances.py,sha256=3_C3cwUPgHmy1WHdNFKrUHmwtaE56ELJ4WnvpTdppSw,8674
-NeuralNetworks/Image.py,sha256=qhTYBTCOO8_8_vYH9Su9luH9iq96ovDfZw9mTKifKVY,4013
-NeuralNetworks/MLP.py,sha256=A86dJTxizUbJleKi-Cvp1W5sySUXZmn8FFvMzkwXR7E,22438
-NeuralNetworks/Plot.py,sha256=yQc1JaQftvkzzT6sLfW9N41v-7lmVq463IZYiKDEzfs,12017
-NeuralNetworks/__init__.py,sha256=cu1B_f8btqzZntZHL3uFQgeVlOoDwgLVDKmlrSSCCec,4777
-neuralnetworks-0.1.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-neuralnetworks-0.1.11.dist-info/METADATA,sha256=5c89cKQDvcUzrAGyBYZuMBehYvU3_DaznFAIay6RbHs,4812
-neuralnetworks-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuralnetworks-0.1.11.dist-info/top_level.txt,sha256=h18nmC1BX7avyAAwKh0OQWezxgXmOpmVtbFq-8Mcbms,15
-neuralnetworks-0.1.11.dist-info/RECORD,,