NeuralNetworks 0.2.0__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,127 +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).
-
-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.
-"""
-
 # Import des dépendances et utilitaires globaux (device, settings, tensorise, etc.)
 from .Dependances import norms, crits, optims, rglen, device, pi, e, tensorise
 
 # Modèle MLP principal + fonction d'entraînement associée
 from .MLP import MLP, losses
 
+from .Trainer import Trainer
+
+from .UI import *
+
 from .Latent import Latent
 
 # Fonctions de chargement/preprocessing des images
 from .tools import image, MNIST, AirfRANS
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NeuralNetworks
-Version: 0.2.0
+Version: 0.2.2
 Summary: Multi-Layer Perceptrons with multi-Fourier encoding, variable learning rate, visualization and PyTorch compilation
 Author-email: Alexandre Brun <alexandre51160@gmail.com>
 License: GPL-3.0-or-later
@@ -40,92 +40,101 @@ de traitement d'images pour l'apprentissage sur des images RGB.
 
 ### Classes
 
-#### MLP
+#### `MLP`
 
-Multi-Layer Perceptron (MLP) avec options avancées :
+Multi-Layer Perceptron (MLP) avec encodage optionnel Fourier (RFF),  
+suivi automatique des pertes, visualisation et compilation PyTorch.
 
-- Encodage Fourier gaussien (RFF) optionnel  
-- Stockage automatique des pertes  
-- Compilation Torch optionnelle pour accélérer l’inférence  
-- Gestion flexible de l’optimiseur, de la fonction de perte et de la normalisation  
+Cette classe fournit :
 
-**Méthodes principales :**
+- Un MLP entièrement configurable (dimensions, normalisation, activation)  
+- Option d'encodage Fourier (Random Fourier Features) sur les entrées  
+- Méthodes pour entraîner le réseau avec mini-batchs et AMP (Automatic Mixed Precision)  
+- Visualisation de l'architecture via visualtorch  
+- Suivi et affichage de la perte d'entraînement  
+- Accès aux poids, biais et nombre de paramètres  
 
-- `MLP(layers, learning_rate, Fourier, optim, crit, norm, name, Iscompiled)`  
-  Initialise le réseau avec toutes les options.
-
-  Les valeurs possibles de `optim`  sont disponibles avec `optims()` 
-  Les valeurs possibles de `crit`  sont disponibles avec `crits()` 
-  Les valeurs possibles de `norm`  sont disponibles avec `norms()` 
+---
 
-- `train(inputs, outputs, num_epochs, batch_size)`  
-  Entraîne le MLP sur des données (`inputs → outputs`) en utilisant AMP et mini-batchs.
+##### Parameters
 
-- `plot(inputs, img_array)`  
-  Affiche l'image originale, la prédiction du MLP et la courbe des pertes.
+| Parameter            | Type          | Optional | Description                                                                                   |
+|----------------------|---------------|----------|-----------------------------------------------------------------------------------------------|
+| `input_size`         | int           | Yes      | Taille des données en entrée au réseau. Default: `1`                                   |
+| `output_size`        | int           | Yes      | Taille des données en sortie au réseau. Default: `1`                                   |
+| `hidden_layers`      | list[int]     | Yes      | Dimensions successives des couches intermédiaires du réseau. Default: `[1]`                   |
+| `sigmas`             | list[float]   | Yes      | Liste de sigma pour encodages RFF. Si None : passthrough. Default: `None`                     |
+| `fourier_input_size` | int           | Yes      | WIP. Default: `2`                                                                             |
+| `nb_fourier`         | int           | Yes      | Nombre de fréquences utilisées pour les Fourier Features. Default: `8`                        |
+| `norm`               | str           | Yes      | Type de normalisation / activation pour les couches cachées (ex: `"Relu"`). Default: `"Relu"` |
+| `name`               | str           | Yes      | Nom du réseau pour identification ou affichage. Default: `"Net"`                              |
 
-- `params()`  
-  Retourne tous les poids du MLP (ligne par ligne) sous forme de liste de `numpy.ndarray`.
+---
 
-- `nb_params()`  
-  Calcule le nombre total de poids dans le MLP.
+##### Attributes
 
-- `neurons()`  
-  Retourne la liste des biais (neurones) de toutes les couches linéaires.
+- `losses : list[float]` — Historique des pertes cumulées lors de l'entraînement  
+- `learnings : list[float]` — Historique des taux d'apprentissage utilisées lors de l'entraînement  
+- `model : nn.Sequential` — MLP complet construit dynamiquement 
+- `name : str` — Nom du réseau
 
 ---
 
-### Fonctions utilitaires
+#### `Trainer`
 
-- `tensorise(obj)`  
-  Convertit un objet array-like ou tensor en `torch.Tensor` float32 sur le device actif.
+---
 
-- `rglen(list)`  
-  Renvoie un range correspondant aux indices d'une liste.
+##### Parameters
 
-- `image_from_url(url, img_size)`  
-  Télécharge une image depuis une URL, la redimensionne et génère :
-  - `img_array` : `np.ndarray (H, W, 3)` pour affichage.  
-  - `inputs` : tenseur `(H*W, 2)` coordonnées normalisées.  
-  - `outputs` : tenseur `(H*W, 3)` valeurs RGB cibles.
+| Parameter    | Type            | Optional | Description                                                                                                     |
+|--------------|-----------------|----------|-----------------------------------------------------------------------------------------------------------------|
+| `*nets`      | *MLP            | No       | Réseaux pour lesquels le trainer va entrainer.                                                                  |
+| `inputs`     | np.array(float) | No       | Données en entrée au réseau.                                                                                    |
+| `outputs`    | np.array(float) | No       | Données en sortie au réseau.                                                                                    |
+| `test_size`  | float           | Yes      | Proportion des données à utiliser pendant l'entrainement. Si None : utilise toutes les données. Default: `None` |
+| `optim`      | str             | Yes      | Nom de l’optimiseur à utiliser (doit exister dans `optims()`). Default: `"Adam"`                                |
+| `init_lr`    | float           | Yes      | Taux d’apprentissage initial pour l’optimiseur. Default: `1e-3`                                                 |
+| `crit`       | str             | Yes      | Fonction de perte à utiliser (doit exister dans `crits()`). Default: `"MSE"`                                    |
+| `batch_size` | float           | Yes      | Taille des minibatchs. Default: `1024`                                                                          |
 
 ---
 
-### Visualisation et comparaison
-
-- `plot(img_array, inputs, *nets)`  
-  Affiche pour chaque réseau l'image reconstruite à partir des entrées.
+##### `Trainer.train`
 
-- `compare(img_array, inputs, *nets)`  
-  Affiche pour chaque réseau l'erreur absolue entre l'image originale et la prédiction,  
-  et trace également les pertes cumulées. Chaque réseau doit posséder :  
+Lancement d'un entrainement avec le trainer définit
 
+| Parameter       | Type    | Optional | Description                             |
+|-----------------|---------|----------|-----------------------------------------|
+| `num_epochs`    | int     | Yes      | Nombres d'itérations à effectuer.       |
+| `activate_tqdm` | boolean | Yes      | Utilisation d'une barre de progression. |
+  
 ---
 
-### Objets et dictionnaires
+### Dictionnaires
 
-#### **norms()**
+#### `norms()`
 
-| **Valeurs**         | **Module PyTorch**        | **Description**                                                                                           |
-|---------------------|---------------------------|-----------------------------------------------------------------------------------------------------------|
-| **"Relu"**          | `nn.ReLU()`               | Fonction d'activation ReLU classique (Rectified Linear Unit).                                             |
-| **"LeakyRelu"**     | `nn.LeakyReLU()`          | ReLU avec un petit coefficient pour les valeurs négatives (paramètre `negative_slope`).                   |
-| **"ELU"**           | `nn.ELU()`                | Fonction d'activation ELU (Exponential Linear Unit), qui a une meilleure gestion des valeurs négatives.   |
-| **"SELU"**          | `nn.SELU()`               | SELU (Scaled Exponential Linear Unit), une version améliorée de l'ELU pour des réseaux auto-normalisants. |
-| **"GELU"**          | `nn.GELU()`               | GELU (Gaussian Error Linear Unit), une activation probabiliste basée sur une fonction gaussienne.         |
-| **"Sigmoid"**       | `nn.Sigmoid()`            | Fonction d'activation Sigmoid, qui produit une sortie entre 0 et 1.                                       |
-| **"Tanh"**          | `nn.Tanh()`               | Fonction d'activation Tanh, avec une sortie dans l'intervalle [-1, 1].                                    |
-| **"Hardtanh"**      | `nn.Hardtanh()`           | Variante de Tanh, avec des sorties limitées entre une plage spécifiée.                                    |
-| **"Softplus"**      | `nn.Softplus()`           | Fonction d'activation qui approxime ReLU mais de manière lissée.                                          |
-| **"Softsign"**      | `nn.Softsign()`           | Fonction d'activation similaire à Tanh mais plus souple, avec des valeurs dans [-1, 1].                   |
+| **Valeurs**         | **Module PyTorch**                                                                         | **Description**                                                                                           |
+|---------------------|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| **"ReLU"**          | [`nn.ReLU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.ReLU.html)           | Fonction d'activation ReLU classique (Rectified Linear Unit).                                             |
+| **"LeakyReLU"**     | [`nn.LeakyReLU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.LeakyReLU.html) | ReLU avec un petit coefficient pour les valeurs négatives (paramètre `negative_slope`).                   |
+| **"ELU"**           | [`nn.ELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.ELU.html)             | Fonction d'activation ELU (Exponential Linear Unit), qui a une meilleure gestion des valeurs négatives.   |
+| **"SELU"**          | [`nn.SELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.SELU.html)           | SELU (Scaled Exponential Linear Unit), une version améliorée de l'ELU pour des réseaux auto-normalisants. |
+| **"GELU"**          | [`nn.GELU()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.GELU.html)           | GELU (Gaussian Error Linear Unit), une activation probabiliste basée sur une fonction gaussienne.         |
+| **"Mish"**          | [`nn.Mish()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Mish.html)           | ReLU différentiable en tout points avec passage négatif.                                                  |
+| **"Softplus"**      | [`nn.Softplus()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Softplus.html)   | Fonction d'activation qui approxime ReLU mais de manière lissée.                                          |
+| **"Sigmoid"**       | [`nn.Sigmoid()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Sigmoid.html)     | Fonction d'activation Sigmoid, qui produit une sortie entre 0 et 1.                                       |
+| **"Tanh"**          | [`nn.Tanh()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Tanh.html)           | Fonction d'activation Tanh, avec une sortie dans l'intervalle [-1, 1].                                    |
+| **"Hardtanh"**      | [`nn.Hardtanh()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Hardtanh.html)   | Variante de Tanh, avec des sorties limitées entre une plage spécifiée.                                    |
+| **"Softsign"**      | [`nn.Softsign()`](https://docs.pytorch.org/docs/stable/generated/torch.nn.Softsign.html)   | Fonction d'activation similaire à Tanh mais plus souple, avec des valeurs dans [-1, 1].                   |
 
 ---
 
-#### **crits()**
+#### `crits()`
 
 | **Valeurs**                    | **Module PyTorch**                  | **Description**                                                                                                            |
 |--------------------------------|-------------------------------------|----------------------------------------------------------------------------------------------------------------------------|
-| **"MSE"**                      | `nn.MSELoss()`                      | Mean Squared Error Loss, utilisée pour les régressions.                                                                    |
+| **"MSE"**                      | [`nn.MSELoss`](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html) | Mean Squared Error Loss, utilisée pour les régressions.                        |
 | **"L1"**                       | `nn.L1Loss()`                       | L1 Loss (erreur absolue), souvent utilisée pour la régularisation.                                                         |
 | **"SmoothL1"**                 | `nn.SmoothL1Loss()`                 | Smooth L1 Loss, une combinaison de L1 et de MSE, moins sensible aux outliers.                                              |
 | **"Huber"**                    | `nn.HuberLoss()`                    | Fonction de perte Huber, une version lissée de L1 et MSE, moins affectée par les grands écarts.                            |
@@ -136,7 +145,7 @@ Multi-Layer Perceptron (MLP) avec options avancées :
 
 ---
 
-#### **optims()**
+#### `optims()`
 
 | **Valeurs**         | **Module PyTorch**                   | **Description**                                                                                                                    |
 |---------------------|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------|
@@ -154,7 +163,9 @@ Multi-Layer Perceptron (MLP) avec options avancées :
 
 ---
 
-### Device et configuration
+### `device`
+
+variable principale d'allocation des performances
 
 #### **Apple Silicon (macOS)**
 - Si le système d'exploitation est macOS (nommé `darwin` dans `platform.system()`), la fonction vérifie si l'accélérateur **Metal Performance Shaders** (MPS) est disponible sur l'appareil.
@@ -181,10 +192,3 @@ Multi-Layer Perceptron (MLP) avec options avancées :
 - Autograd configuré pour privilégier les performances
 
 ---
-
-### Notes générales
-
-- Toutes les méthodes de MLP utilisent les tenseurs sur le device global (CPU ou GPU)  
-- Les images doivent être normalisées entre 0 et 1  
-- Les fonctions interactives (`plot`, `compare`) utilisent matplotlib en mode interactif  
-- Le module est conçu pour fonctionner dans Jupyter et scripts Python classiques

neuralnetworks-0.2.2.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,,