Comment visualiser les architectures de réseaux neuronaux en Python

Un guide rapide pour créer une représentation schématique de vos réseaux de neurones à l'aide de Jupyter ou Google Colab

Souvent, lorsque nous travaillons avec des réseaux de neurones artificiels ou d'autres variantes telles que les réseaux de neurones à convolution ou les réseaux de neurones récurrents, nous souhaitons visualiser et créer une représentation schématique de notre modèle compilé. Cela peut résoudre deux problèmes :

1. Tout en définissant et en entraînant plusieurs modèles, nous pouvons visualiser la profondeur de notre modèle et comparer différentes couches et la manière dont elles sont disposées séquentiellement.
2. Permet une meilleure compréhension de la structure du modèle, des fonctions d'activation utilisées dans chaque couche, de la forme de chaque couche (nombre de neurones) et des paramètres qui doivent être entraînés

Il existe quelques packages facilement disponibles en python qui peuvent créer une représentation visuelle de nos modèles de réseau neuronal. Les trois premiers packages peuvent être utilisés avant même qu'un modèle ne soit formé (le modèle doit uniquement être défini et compilé) ; cependant, Tensor Boards nécessite que l'utilisateur entraîne le modèle sur des données précises avant que l'architecture puisse être visualisée.

1. Visualiseur ANN
2. Kéras visuels
3. Tracé modèle Keras
4. Conseil tenseur

pip installer visualkeraspip installer ann_visualizerpip installer graphviz

Nous n'avons pas besoin d'installer le « Tensor Board » et le « Keras Model Plot » séparément. Cela viendra avec l'installation initiale de Tensorflow & Keras.

Nous ne pouvons utiliser que quelques-unes des bibliothèques répertoriées ci-dessous. La plupart des bibliothèques peuvent convertir un modèle TensorFlow en diagramme sans l'entraîner explicitement sur les données. Vous pouvez considérer cela comme une source unique de vérité. Certaines bibliothèques, comme Pandas, Skimage et OpenCV, seront utiles lors de la lecture de données ou d'images structurées.

# Importer les bibliothèques nécessairesimporter des pandas en tant que pdimporter numpy en tant que np # Importer numpyà partir des données d'importation skimage, io # Importer la bibliothèque skimage (données - Images de test et exemples de données.# io - Lecture, enregistrement et affichage d'images.)à partir de skimage.color importer rgb2grayimport matplotlib.pyplot as plt # Importer matplotlib.pyplot (Cadre de traçage en Python.)%matplotlib en ligneimport os # Ce module fournit un moyen portable d'utiliser les fonctionnalités dépendantes du système d'exploitation.os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'importer des avertissements# Supprimer les avertissementsavertissements.filterwarnings('ignorer')à partir de l'affichage d'importation IPython.displayimporter cv2 comme cv
à partir de sklearn.metrics, importez confusion_matrixdepuis sklearn.model_selection import train_test_splità partir des utilitaires d'importation tensorflow.kerasà partir de tensorflow.keras.models import séquentiel,load_modelà partir de tensorflow.keras.layers, importez Dense, Dropout, Flatten, Conv2D, MaxPool2D, BatchNormalizationdepuis tensorflow.keras.optimizers importer Adamimporter tensorflow en tant que tfimporter seaborn en tant que sns

Quelques liens utiles pour explorer davantage de contenu autour des ANN et des CNN à partir de zéro.

Nous définirons trois modèles CNN différents avec des hyperparamètres différents. Idéalement, dans le monde réel, nous visons à mettre en œuvre différentes architectures pour maximiser la précision ou toute mesure pertinente, étant donné que nous construisons le modèle pour une tâche de classification multi-catégories. Notre choix du type de problème n’aura aucun impact sur la manière d’utiliser les packages de visualisation.

Nous avons créé des fonctions définies par l'utilisateur pour créer trois modèles différents séparément avec un nombre différent de couches CNN, un pooling maximal et des couches denses.

4.1 – Architecture 1 — Couches CNN peu profondes + couches ANN

def construct_model() :modèle = Séquentiel()model.add(Conv2D(filters=64, kernel_size=(3, 3), input_shape=(128, 128, 1), activation='relu'))model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))modèle.add(MaxPool2D((2, 2)))model.add(Aplatir())model.add(Dense(256, activation='relu'))model.add(Dense(12, activation='softmax'))model.compile(loss='categorical_crossentropy', optimiseur='adam', metrics=['accuracy'])modèle de retour

4.2 — Architecture 2 — Couches CNN profondes + ANN peu profondes

def sconstruct_model() :smodel = Séquentiel()smodel.add(Conv2D(filters=64, kernel_size=(3, 3), input_shape=(128, 128, 3), activation='relu'))smodel.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Aplatir())smodel.add(Dense(256, activation='relu'))smodel.add(Dense(12, activation='softmax'))#optimiseur = Adam(lr=0.001)smodel.compile(loss='categorical_crossentropy', optimiseur='adam', metrics=['accuracy'])#model.summary()modèle de retour

4.3 — Architecture 3 — Couches CNN et ANN profondes

def cconstruct_model (learningRate) :smodel = Séquentiel()smodel.add(Conv2D(filters=32, kernel_size=(3, 3), input_shape=(128, 128, 1), activation='relu'))smodel.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))smodel.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Aplatir())smodel.add(Dense(256, activation='relu'))smodel.add(Dense(256, activation='relu'))smodel.add(Dense(12, activation='softmax'))optimiseur = Adam (lr = learningRate)smodel.compile(loss='categorical_crossentropy', optimiseur=optimiseur, metrics=['accuracy'])smodel.summary()modèle de retourmodèle = cconstruct_model (0.001)

Un module Python nommé ANN Visualizer permet de visualiser un réseau de neurones artificiels avec quelques lignes de code (Gheorghiu, 2022). Il utilise Keras et le module Graphviz de Python pour produire un graphique de réseau neuronal soigné et attrayant. Vous avez la possibilité de visualiser l'ensemble du réseau d'apprentissage profond ou simplement le réseau de neurones convolutifs que vous avez créé grâce aux progrès de l'apprentissage profond (Shah, 2018).

Utilisez la structure suivante ci-dessous pour générer une représentation PDF de votre réseau neuronal. Cependant, avant cela, nous devons compiler les modèles ci-dessus.

modèle = construct_model()

ann_viz(model, view=True, filename=”network.gv”, title=”MyNeural Network”)

• modèle - Modèle séquentiel de Keras
• voir - Visualisez le graphique après l'appel de ann_viz()
• nom de fichier - Nom du fichier
• titre - Tout titre spécifique pour désigner le graphique

depuis ann_visualizer.visualize importer ann_vizann_viz(model, view=True, filename=”cconstruct_model”, title=”CNN — Modèle 1 — Architecture simple”)

Un outil Python appelé Visualkeras facilite la visualisation des conceptions de réseaux neuronaux Keras (soit séparément, soit dans le cadre de TensorFlow). La majorité des besoins en matière de style peuvent être satisfaits facilement. Les réseaux de neurones convolutifs (CNN) bénéficient considérablement du développement d'architectures en couches. La plupart des modèles, y compris les réseaux à action directe simple, bénéficient grandement de la génération d'une architecture de style graphique, prise en charge par ce module (Gavrikov, 2022).

model1=construct_model()model2=sconstruct_model()model3=cconstruct_model(0.009)importer des visuelsà partir de PIL importer ImageFontvisualkeras.layered_view(model1, légende=True)visualkeras.layered_view(model2, légende=True)visualkeras.layered_view(model3, légende=True)

La keras.utils.plot_model fournit des fonctions intégrées pour tracer un modèle défini et compilé via Keras à l'aide des packages Graphviz et pydot. Graphiquement, il est moins intuitif que les packages utilisés ci-dessus, mais il décrit l'architecture de base d'un modèle séquentiel (Team, sd).

tf.keras.utils.plot_model(modèle1,to_file="modèle.png",show_shapes=Vrai,show_dtype=Faux,show_layer_names=Vrai,rangdir="TB",expand_nested=Vrai,ppp = 96,layer_range=Aucun,show_layer_activations=Vrai,)

Quelques hyperparamètres à considérer :

1. modèle: Une instance du modèle compilé Keras ou de l'objet modèle
2. vers_fichier : Nom de fichier de l'image
3. show_shapes : afficher la dimension et la forme de chaque couche du réseau neuronal
4. show_layer_activation : afficher les fonctions d'activation utilisées dans les neurones

TensorBoard est une interface de tableau de bord qui permet aux utilisateurs de visualiser les journaux sur différentes exécutions de modèles. Les journaux peuvent aller du suivi de toute mesure de validation de modèle comme la précision, le rappel, le RMSE, le MAPE et le MSE à différentes époques à la création d'un graphique conceptuel de l'architecture du modèle. Il s'agit d'un outil puissant pour visualiser si le modèle prévu correspond à la conception attendue tout en fournissant des informations sur la façon dont un modèle peut être modifié à l'aide d'un graphique de niveau opérationnel.

Pour utiliser cette fonctionnalité, nous devons d'abord charger TensorBoard, puis créer un répertoire de journaux.

Tensorboard %load_extdepuis datetime import datetimeà partir de keras d'importation tensorflow# Définissez le rappel Keras TensorBoard.logdir="logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

Créez le rappel Keras TensorBoard et spécifiez le répertoire des journaux avant l'entraînement. Vous pouvez vous assurer que les données graphiques sont enregistrées pour la visualisation TensorBoard en fournissant ce rappel à model.fit(). Une fois que vous avez invoqué TensorBoard, le chargement peut prendre quelques minutes.

modèle.fit(X2_train, Y2_train,batch_size=64,époques = 5,rappels=[tensorboard_callback])

Remarque : X2_train et Y2_train sont des ensembles de données d'entraînement qui ne sont pas reflétés dans les codes ci-dessus. Vous pouvez les remplacer par vos propres données d’entraînement.

TensorBoard affiche toujours le graphique au niveau opérationnel par défaut. (La balise « Par défaut » est mise en surbrillance à gauche.) Le graphique est à l'envers par rapport au code car les données circulent de bas en haut. Mais comme vous pouvez le voir, le graphique ressemble à peu près à la description du modèle Keras, avec des arêtes supplémentaires menant à d'autres nœuds de calcul (Tensorflow, 2022).

Vous trouverez plus d'informations sur l'utilisation de TensorBoard sous Référence.

D'un point de vue commercial, où un utilisateur doit présenter son analyse à un groupe de parties prenantes, ces diagrammes ajoutent plus de complexité à la discussion. Ils ne constituent peut-être pas une valeur ajoutée extrême. Cependant, d’un point de vue académique et d’apprentissage, il est intéressant d’utiliser ces packages pour afficher ces architectures d’apprentissage profond. Le visualiseur ANN, pour moi, se démarque des autres car il est facile à digérer le diagramme, alors que la sortie graphique de TensorBoard nécessite plus de détails techniques avant que les résultats puissent être consommés.

Gavrikov, P. (2022 avril 13). visualkeras pour Keras / TensorFlow. GitHub. https://github.com/paulgavrikov/visualkeras

Gheorghiu, T. (2022 octobre 21). Visualiseur ANN. GitHub. https://github.com/RedaOps/ann-visualizer

Shah, A. (2018 avril 28). Visualiser les réseaux de neurones artificiels (ANN) avec une seule ligne de code. Moyen. https://towardsdatascience.com/visualizing-artificial-neural-networks-anns-with-just-one-line-of-code-b4233607209e

Débordement de pile. (sd). apprentissage automatique — Comment visualisez-vous les architectures de réseaux neuronaux ? Échange de pile de science des données. Récupéré le 29 octobre 2022 sur https://datascience.stackexchange.com/questions/12851/how-do-you-visualize-neural-network-architectures

Équipe, K. (sd). Documentation Keras : utilitaires de traçage de modèles. Keras.io. Récupéré le 29 octobre 2022 sur https://keras.io/api/utils/model_plotting_utils/#modeltodot-function

Tensorflow. (2022, 6 janvier). Examen du graphique TensorFlow | Tableau Tenseur. TensorFlow. https://www.tensorflow.org/tensorboard/graphs

Comment visualiser les architectures de réseaux neuronaux en Python republié à partir de la source https://towardsdatascience.com/how-to-visualize-neural-network-architectures-in-python-567cd2aa6d62?source=rss—-7f60cf5620c9—4 via https:// versdatascience.com/feed

<!–

->