[PYTHON] Visualisieren Sie die innere Schicht des neuronalen Netzwerks

Dies ist mein erster Beitrag. Außerdem bin ich ein Anfänger im maschinellen Lernen. Ich denke, dass es viele Teile gibt, die schwer zu sehen sind, wie zum Beispiel seltsame Dinge aufgrund mangelnden Verständnisses zu sagen, aber ich würde es begrüßen, wenn Sie mich warm beobachten könnten!

Klasseninitialisierung

visualize.py

from keras.datasets import mnist
from keras.utils import to_categorical
from keras.models import Model, model_from_json
from keras.layers import Input, Conv2D, MaxPooling2D, Dense, Flatten, Dropout
import numpy as np
import seaborn as sns
import os


class Visualize_CNN():
    def __init__(self):
        self.conv1_filter_num = 32
        self.conv1_filter_size = (3,3)
        self.conv1_strides = 1
        self.pool1_filter_size = (2,2)

        self.conv2_filter_num = 64
        self.conv2_filter_size = (5,5)
        self.conv2_strides = 1
        self.pool2_filter_size = (2,2)

        self.dense1_output = 1024
        self.dense2_output = 10

        self.epochs = 1
        self.batch_size = 128

        self.figsize = (10,10)
        self.save_file_path = "../data/model"

Daten lesen

visualize.py

    def load_data(self):
        (x_train, y_train),(x_test,y_test) = mnist.load_data()
        x_train = x_train.astype("float32")/ 256
        x_train = x_train.reshape((-1,28,28,1))
        x_test = x_test.astype("float32")/ 256
        x_test = x_test.reshape((-1,28,28,1))
        y_train = to_categorical(y_train)
        y_test = to_categorical(y_test)
        
        return x_train, y_train, x_test, y_test

Die Vorverarbeitung erfolgt durch Lesen von Mnist-Daten aus keras.datasets. Was ich zu x_train und x_test ging, war Typspezifikation und Normalisierung. Die diesmal durchgeführte Normalisierung ist ** Min-Max-Normalisierung **. Wenn Sie es in einer mathematischen Formel schreiben,

y = \frac{x - x_{min}}{x_{max} - x_{min}}

x_{max}:Maximalwert in den angegebenen Daten,
x_{min}:Ist der Mindestwert in den angegebenen Daten

Es wird sein. Wenn Sie die angegebenen Daten durch die Breite der Maximal- und Minimalwerte dividieren, können Sie den Maximalwert auf 1 und den Minimalwert auf 0 skalieren, oder? Daher denke ich, dass es ** Min-Max-Normalisierung ** ist. Die Daten, die dieses Mal verarbeitet werden, sind mnist. Also der Wert jedes Pixels auf einer Graustufe? Da wir wissen, dass dies 0 bis 255 ist, wird 0 im Minimalwertteil der Formel und 255 im Maximalwertteil eingegeben. y_train und y_test sind One-Hot-Label-Daten. Dieses Mal werden die Daten automatisch konvertiert, indem jedes Argument in keras.utils to_categorical zugewiesen wird.

Modell bauen

build_model.py

    def creat_model(self):
        input_model = Input(shape=(28,28,1))
        conv1 = Conv2D(self.conv1_filter_num,
                       self.conv1_filter_size,
                       padding="same",
                       activation="relu")(input_model)
        pool1 = MaxPooling2D(self.pool1_filter_size)(conv1)
        conv2 = Conv2D(self.conv2_filter_num,
                       self.conv2_filter_size,
                       padding="same",
                       activation="relu"
                      )(pool1)
        pool2 = MaxPooling2D(self.pool2_filter_size)(conv2)
        flat = Flatten()(pool2)
        dense1 = Dense(self.dense1_output,
                      activation="relu")(flat)
        dropout = Dropout(0.25)(dense1)
        dense2 = Dense(self.dense2_output,
                      activation="softmax")(dropout)
        
        model = Model(inputs=input_model, output=dense2)
        return model

Das diesmal gebaute Modell ist so einfach wie zweimal zu falten und zu verbinden. Die Anzahl der Filter (Anzahl der Spalten?) Und die Größe jeder Ebene sind im Teil ** Klasseninitialisierung ** aufgeführt.

Modellschulung und Lagerung

visualize.py

    
    def train_and_save(self):
        x_train, y_train, x_test, y_test = self.load_data()
        model =  self.creat_model_()
        model.compile(optimizer="adam",
                     loss="categorical_crossentropy",
                     metrics=["accuracy"])
        #model.summary()
        history = model.fit(x_train, y_train, 
                           batch_size=self.batch_size,
                           epochs=self.epochs,
                           verbose=2,
                           validation_data=(x_test, y_test))
　　　　json_string = model.to_json()
       open(os.path.join(self.save_file_path, "model.json"),"w").write(json_string)
       model.save_weights(os.path.join(self.save_file_path, "model_weights.h5"))
       print("saving succsessful")

Trainieren Sie das gebaute Modell und speichern Sie das Modell und die trainierten Gewichte. Es scheint, dass model.save (save_file_path) das Modell und das Gewicht gleichzeitig speichert, aber ich wusste nicht, wann ich den Code geschrieben habe, also speichere ich sie separat.

Visualisierung der mittleren Schicht

visualize.py

    def visualize(self):
        x_train,a,b,c = self.load_data()
        json_string = open(os.path.join(self.save_file_path, "model.json")).read()
        model = model_from_json(json_string)
        model.load_weights(os.path.join(self.save_file_path, "model_weights.hdf5"))
        layers = model.layers[1:5]
        outputs = [layer.output for layer in layers]
        acctivation_model = Model(inputs=model.input, output=outputs)
        acctivation_model.summary()

        image = x_train[1].reshape(-1,28,28,1)#Wenn Sie das Eingabebild x ändern möchten_train[j]Bitte ändern Sie j!
        plt.imshow(image.reshape(28,28))
        activation = acctivation_model.predict(image)
        x_axis = 8
        y_axis = 8
        for j in range(len(activation)):
            cul_num = activation[j].shape[3]
            act = activation[j]
            plt.figure(figsize=(self.figsize))

            for i in range(cul_num):
                plt.subplot(8,8,i+1)
                sns.heatmap(act[0,:,:,i])
        plt.show()

Das zuletzt gespeicherte Modell und die Gewichte werden geladen, das Modell, das die Ausgabe anderer Ebenen als der vollständig verbundenen Ebene ausgibt, wird neu definiert und die Ausgabe wird als Heatmap ausgegeben.

Ergebnis

Das Ergebnis ist wie folgt. ** Eingabebild ** ** Ausgabe der Faltungsschicht 1 ** ** Ausgabe der Faltungsschicht 2 **

Zusammenfassung

Oben habe ich versucht, die mittlere Schicht des ersten Beitrags und das neuronale Netzwerk zu visualisieren! war. Wenn Sie dies hier tun, wird es leichter zu sehen sein! Ratschläge sind willkommen! Vielen Dank für das Anschauen bis zum Ende m (_ _) m