Hoe neurale netwerkarchitecturen in Python te visualiseren?

Een korte handleiding voor het maken van een schematische weergave van uw neurale netwerken met Jupyter of Google Colab

Terwijl we werken met kunstmatige neurale netwerken of andere variaties zoals Convolution Neural Networks of Recurrent Neural Networks, willen we vaak een schematische weergave van ons gecompileerde model visualiseren en creëren. Dit kan twee doelen oplossen:

1. Door het definiëren en trainen van meerdere modellen kunnen we de diepte van ons model visualiseren en verschillende lagen vergelijken en hoe ze opeenvolgend zijn vastgelegd.
2. Maakt een beter begrip mogelijk van de modelstructuur, de activeringsfuncties die in elke laag worden gebruikt, de vorm van elke laag (aantal neuronen) en parameters die moeten worden getraind

Er zijn een paar pakketten beschikbaar in Python die een visuele weergave van onze neurale netwerkmodellen kunnen creëren. De eerste drie pakketten kunnen al worden gebruikt voordat een model is getraind (het model hoeft alleen te worden gedefinieerd en gecompileerd); Tensor Boards vereist echter dat de gebruiker het model traint op nauwkeurige gegevens voordat de architectuur kan worden gevisualiseerd.

1. ANN Visualisatie
2. Visuele Keras
3. Keras-modelplot
4. Tensorbord

pip installeer visualkeraspip installeer ann_visualizerpip install graphviz

We hoeven het “Tensor Board” en “Keras Model Plot” niet afzonderlijk te installeren. Dit komt met de eerste installatie van Tensorflow & Keras.

Het is mogelijk dat we slechts enkele van de hieronder genoemde bibliotheken gebruiken. De meeste bibliotheken kunnen een TensorFlow-model naar een diagram converteren zonder het expliciet op gegevens te trainen. Je kunt dit beschouwen als één enkele bron van waarheid. Sommige bibliotheken, zoals Pandas, Skimage en OpenCV, zullen van pas komen bij het lezen van gestructureerde gegevens of afbeeldingen.

# Importeer de benodigde bibliothekenimporteer panda's als pdimporteer numpy als np # Importeer numpyvan skimage importgegevens, io # Importeer skimage-bibliotheek (gegevens - Testafbeeldingen en voorbeeldgegevens.# io - Afbeeldingen lezen, opslaan en weergeven.)van skimage.color importeer rgb2grayimport matplotlib.pyplot as plt # Importeer matplotlib.pyplot (Plotraamwerk in Python.)% matplotlib inlineimport os # Deze module biedt een draagbare manier om besturingssysteemafhankelijke functionaliteit te gebruiken.os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'importwaarschuwingen# Onderdruk waarschuwingenwaarschuwingen.filterwarnings('negeren')van IPython.display importweergaveimport cv2 als cv
van sklearn.metrics importeer verwarring_matrixvan sklearn.model_selection importeer train_test_splitvan tensorflow.keras import utilsvan tensorflow.keras.models importeer Sequential,load_modelvan tensorflow.keras.layers importeer Dense, Dropout, Flatten, Conv2D, MaxPool2D, BatchNormalizationvan tensorflow.keras.optimizers importeer Adamimporteer tensorflow als tfimporteer seaborn als sns

Enkele nuttige links voor het helemaal opnieuw verkennen van meer inhoud rond ANN's en CNN's.

We zullen drie verschillende CNN-modellen definiëren met verschillende hyperparameters. Idealiter streven we er in de echte wereld naar om verschillende architecturen te implementeren om de nauwkeurigheid of relevante meetgegevens te maximaliseren, aangezien we het model aan het bouwen zijn voor een classificatietaak met meerdere categorieën. Onze keuze van het probleemtype heeft geen enkele invloed op de manier waarop de visualisatiepakketten moeten worden gebruikt.

We hebben door de gebruiker gedefinieerde functies gemaakt om drie verschillende modellen afzonderlijk te bouwen met een verschillend aantal CNN-lagen, max-pooling en dichte lagen.

4.1 – Architectuur 1 – Ondiepe CNN-lagen + ANN-lagen

def construct_model():model = Sequentieel ()model.add(Conv2D(filters=64, kernel_size=(3, 3), input_shape=(128, 128, 1), activatie='relu'))model.add(Conv2D(filters=64, kernel_size=(3, 3), activatie='relu'))model.add(MaxPool2D((2, 2)))model.add(afvlakken())model.add(Dense(256, activatie='relu'))model.add(Dense(12, activatie='softmax'))model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['nauwkeurigheid'])retourmodel

4.2 — Architectuur 2 — Diepe CNN + ondiepe ANN-lagen

def sconstruct_model():smodel = Opeenvolgend()smodel.add(Conv2D(filters=64, kernel_size=(3, 3), input_shape=(128, 128, 3), activatie='relu'))smodel.add(Conv2D(filters=64, kernel_size=(3, 3), activatie='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activatie='relu'))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activatie='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activatie='relu'))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activatie='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(afvlakken())smodel.add(Dense(256, activatie='relu'))smodel.add(Dense(12, activatie='softmax'))#optimizer = Adam(lr=0.001)smodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['nauwkeurigheid'])#Model Samenvatting()smodel retourneren

4.3 — Architectuur 3 — Diepe CNN- en ANN-lagen

def cconstruct_model(leersnelheid):smodel = Opeenvolgend()smodel.add(Conv2D(filters=32, kernel_size=(3, 3), input_shape=(128, 128, 1), activatie='relu'))smodel.add(Conv2D(filters=32, kernel_size=(3, 3), activatie='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=64, kernel_size=(3, 3), activatie='relu'))smodel.add(Conv2D(filters=64, kernel_size=(3, 3), activatie='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activatie='relu'))smodel.add(Conv2D(filters=128, kernel_size=(3, 3), activatie='relu'))smodel.add(MaxPool2D((2, 2)))smodel.add(afvlakken())smodel.add(Dense(256, activatie='relu'))smodel.add(Dense(256, activatie='relu'))smodel.add(Dense(12, activatie='softmax'))optimizer = Adam(lr=leersnelheid)smodel.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['nauwkeurigheid'])smodel.samenvatting()smodel retournerenmodel=cconstruct_model(0.001)

Een Python-module genaamd ANN Visualizer maakt het mogelijk om met een paar regels code een kunstmatig neuraal netwerk te visualiseren (Gheorghiu, 2022). Het maakt gebruik van de Graphviz-module van Keras en Python om een ​​nette en aantrekkelijke neurale netwerkgrafiek te produceren. Je hebt de flexibiliteit om het hele Deep Learning Network te visualiseren of alleen het Convolutional Neural Network dat je hebt gecreëerd, gedreven door de vooruitgang in deep learning (Shah, 2018).

Gebruik de volgende structuur hieronder om een ​​pdf-weergave van uw neurale netwerk te genereren. Daarvoor moeten we echter de bovenstaande modellen compileren.

model=construct_model()

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

• model- Sequentieel model van Keras
• weergave - Visualiseer de grafiek nadat ann_viz() is aangeroepen
• bestandsnaam - Naam van het bestand
• titel — Elke specifieke titel om de grafiek aan te duiden

van ann_visualizer.visualize importeer ann_vizann_viz(model, view=True, filename=”cconstruct_model”, title=”CNN — Model 1 — Eenvoudige architectuur”)

Een Python-tool genaamd Visualkeras maakt het gemakkelijker om Kera's neurale netwerkontwerpen te bekijken (afzonderlijk of als onderdeel van TensorFlow). Aan de meeste stylingbehoeften kan met gemak worden voldaan. Convolutionele neurale netwerken (CNN's) profiteren aanzienlijk van de ontwikkeling van gelaagde architecturen. De meeste modellen, inclusief eenvoudige feed-forward-netwerken, profiteren enorm van het genereren van grafiekstijlarchitectuur, die deze module ondersteunt (Gavrikov, 2022).

model1=construct_model()model2=sconstruct_model()model3=cconstruct_model(0.009)visualkera's importerenvan PIL-import ImageFontvisualkeras.layered_view(model1, legenda=Waar)visualkeras.layered_view(model2, legenda=Waar)visualkeras.layered_view(model3, legenda=Waar)

De keras.utils.plot_model biedt ingebouwde functies om een ​​model uit te zetten dat is gedefinieerd en gecompileerd via Keras met behulp van Graphviz- en pydot-pakketten. Grafisch is het minder intuïtief dan de hierboven gebruikte pakketten, maar het schetst de basisarchitectuur van een sequentieel model (Team, zd).

tf.keras.utils.plot_model(model1,to_file="model.png",show_shapes=Waar,show_dtype=Onwaar,show_layer_names=Waar,ranglijst = "TB",expand_nested=Waar,dpi=96,layer_range=Geen,show_layer_activations=Waar,)

Enkele hyperparameters waarmee u rekening moet houden:

1. model: Een exemplaar van Kera's gecompileerde model of modelobject
2. naar_bestand: Bestandsnaam van de afbeelding
3. show_shapes: dimensie en vorm van elke laag in het neurale netwerk weergeven
4. show_layer_activation: activeringsfuncties weergeven die binnen de neuronen worden gebruikt

TensorBoard is een dashboardinterface waarmee gebruikers logboeken van verschillende modelruns kunnen visualiseren. Logboeken kunnen variëren van het volgen van elke modelvalidatiemaatstaf, zoals nauwkeurigheid, terugroepen, RMSE, MAPE en MSE over verschillende tijdperken, tot het maken van een conceptuele grafiek van de architectuur van het model. Het is een krachtig hulpmiddel om te visualiseren of het beoogde model overeenkomt met het verwachte ontwerp, terwijl u inzichten krijgt over hoe een model kan worden gewijzigd met behulp van een grafiek op niveau.

Om deze functionaliteit te gebruiken, moeten we eerst TensorBoard laden en vervolgens een logmap maken.

%load_ext tensorborduit datetime importeer datetimevan tensorflow import keras# Definieer de Keras TensorBoard-callback.logdir="logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

Maak de Keras TensorBoard-callback en geef de logmap op voordat u gaat trainen. U kunt ervoor zorgen dat grafiekgegevens worden vastgelegd voor TensorBoard-visualisatie door deze callback naar model.fit() op te geven. Nadat u het TensorBoard hebt aangeroepen, kan het enkele minuten duren om te laden.

model.pasvorm(X2_trein, Y2_trein,batch_grootte=64,tijdperken=5,callbacks=[tensorboard_callback])

Opmerking: X2_train en Y2_train zijn trainingsgegevenssets die niet worden weerspiegeld in de bovenstaande codes. Deze kun je vervangen door eventuele eigen trainingsgegevens.

TensorBoard toont standaard altijd de grafiek op niveau. (De tag 'Default' is aan de linkerkant gemarkeerd.) De grafiek staat ondersteboven in vergelijking met de code, omdat de gegevens van onder naar boven stromen. Maar zoals u kunt zien, lijkt de grafiek grofweg op de beschrijving van het Keras-model, met extra randen die naar andere rekenknooppunten leiden (Tensorflow, 2022).

Meer context over het gebruik van TensorBoard vindt u onder Referentie.

Vanuit commercieel oogpunt, waarbij een gebruiker zijn analyse aan een groep belanghebbenden moet presenteren, voegen deze diagrammen meer complexiteit toe aan de discussie. Ze hebben misschien geen extreme toegevoegde waarde. Vanuit academisch en leerperspectief is het echter waardevol om deze pakketten te gebruiken om deze deep learning-architecturen weer te geven. Voor mij onderscheidt de ANN-visualizer zich van de rest, omdat het gemakkelijk is om het diagram te verwerken, terwijl de grafiekuitvoer van TensorBoard meer technische details vereist voordat de resultaten kunnen worden geconsumeerd.

Gavrikov, P. (2022, 13 april). visualkeras voor Keras / TensorFlow​ GitHub. https://github.com/paulgavrikov/visualkeras

Gheorghiu, T. (2022, 21 oktober). ANN Visualisatie​ GitHub. https://github.com/RedaOps/ann-visualizer

Sjah, A. (2018, 28 april). Visualiseer kunstmatige neurale netwerken (ANN's) met slechts één regel code. Medium. https://towardsdatascience.com/visualizing-artificial-neural-networks-anns-with-just-one-line-of-code-b4233607209e

Stapeloverloop. (nd). machine learning – Hoe visualiseer je neurale netwerkarchitecturen? Data Science Stack-uitwisseling. Opgehaald op 29 oktober 2022, van https://datascience.stackexchange.com/questions/12851/how-do-you-visualize-neural-network-architectures

Team, K. (zd). Keras-documentatie: Hulpprogramma's voor het plotten van modellen. Keras.io. Opgehaald op 29 oktober 2022, van https://keras.io/api/utils/model_plotting_utils/#modeltodot-function

Tensorstroom. (2022, 6 januari). De TensorFlow-grafiek onderzoeken | TensorBoard. TensorFlow. https://www.tensorflow.org/tensorboard/graphs

Hoe neurale netwerkarchitecturen in Python te visualiseren, opnieuw gepubliceerd vanuit de bron https://towardsdatascience.com/how-to-visualize-neural-network-architectures-in-python-567cd2aa6d62?source=rss—-7f60cf5620c9—4 via https:// richtingdatascience.com/feed

<!–

->