Visualisez la couche interne du réseau neuronal

Ceci est mon premier message posté. De plus, je suis un débutant en apprentissage automatique. Je pense qu'il y a beaucoup de parties difficiles à voir, comme dire des choses étranges par manque de compréhension, mais j'apprécierais que vous me surveilliez chaleureusement!

Initialisation de classe

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"

Lire les données

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

Le prétraitement est effectué en lisant les données mnist à partir de keras.datasets. Ce que j'ai fait pour x_train et x_test était la spécification de type et la normalisation. La normalisation effectuée cette fois est la ** normalisation Min-Max **. Si vous l'écrivez dans une formule mathématique,

y = \frac{x - x_{min}}{x_{max} - x_{min}}
x_{max}:Valeur maximale dans les données données,
x_{min}:Est la valeur minimale dans les données données

Ce sera. Si vous divisez chaque donnée donnée par la largeur des valeurs maximale et minimale, vous pouvez mettre à l'échelle la valeur maximale à 1 et la valeur minimale à 0, non? Par conséquent, je pense que c'est la ** normalisation Min-Max **. Les données manipulées cette fois sont mnist. Alors, la valeur de chaque pixel sur une échelle de gris? Puisque nous savons que 0 à 255, 0 est entré dans la partie valeur minimale de la formule et 255 est entré dans la partie valeur maximale. y_train et y_test sont des données one-hot label. Cette fois, en donnant chaque argument à to_categorical dans keras.utils, les données sont automatiquement converties.

Construire un modèle

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

Le modèle construit cette fois est aussi simple que de le plier deux fois et de le joindre. Le nombre de filtres (nombre de colonnes?) Et la taille de chaque couche sont listés dans la partie ** initialisation de classe **.

Formation et stockage des modèles

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")

Entraînez le modèle construit et enregistrez le modèle et les poids entraînés. Il semble que model.save (save_file_path) enregistre le modèle et le poids en même temps, mais je ne savais pas quand j'ai écrit le code, donc je les enregistre séparément.

Visualisation de la couche intermédiaire

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)#Si vous souhaitez modifier l'image d'entrée x_train[j]Veuillez changer 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()

Le dernier modèle et les poids enregistrés sont chargés, le modèle qui génère la sortie des couches autres que la couche entièrement connectée est redéfini et la sortie est sortie sous forme de carte thermique.

résultat

Le résultat est le suivant. ** Image d'entrée ** Figure_1.png ** Sortie de la couche de convolution 1 ** Figure_2.png ** Sortie de la couche de convolution 2 ** Figure_4.png

Résumé

Ci-dessus, j'ai essayé de visualiser la couche intermédiaire du premier post et le réseau de neurones! était. Si vous faites cela ici, ce sera plus facile à voir! Les conseils etc. sont les bienvenus! Merci d'avoir regardé jusqu'au bout m (_ _) m

Recommended Posts

Visualisez la couche interne du réseau neuronal
Implémenter un réseau neuronal à 3 couches
L'histoire de la création d'un réseau neuronal de génération musicale
Implémentation d'un réseau de neurones à deux couches 2
Touchez l'objet du réseau neuronal
Implémentation d'un réseau neuronal à 3 couches (pas d'apprentissage)
Comprendre le nombre de paramètres d'entrée / sortie du réseau neuronal convolutif
[NNabla] Comment obtenir la sortie (variable) de la couche intermédiaire du réseau construit
Visualisez le vocabulaire caractéristique d'un document avec D3.js
Bases de PyTorch (2) -Comment créer un réseau de neurones-
Implémentation d'un réseau de neurones convolutifs utilisant uniquement Numpy
Visualisez la trajectoire de Hayabusa 2
[NNabla] Comment ajouter une nouvelle couche entre les couches intermédiaires d'un réseau pré-construit
Un diagramme de réseau a été créé avec les données du COVID-19.
Construction d'un réseau neuronal qui reproduit XOR par Z3
Comment dessiner facilement la structure d'un réseau de neurones sur Google Colaboratory à l'aide de "convnet-tiroir"
Qu'est-ce que le réseau neuronal convolutif?
J'ai essayé de mettre en œuvre un réseau de neurones à deux couches
Visualisez l'état de la réponse du recensement national 2020
L'histoire de l'exportation d'un programme
Une commande pour vérifier facilement la vitesse du réseau sur la console
[NNabla] Comment supprimer le niveau intermédiaire d'un réseau prédéfini
Résumons les fonctions de base de TensorFlow en créant un réseau neuronal qui apprend les portes XOR.
Composez avec un réseau neuronal! Run Magenta
Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow
Mesurer la force de l'association dans un tableau croisé
J'ai essayé d'améliorer la précision de mon propre réseau neuronal
[NNabla] Comment ajouter une couche de quantification à la couche intermédiaire d'un modèle entraîné
Visualisez les effets de l'apprentissage profond / de la régularisation
Persister le réseau de neurones construit avec PyBrain
[python] [meta] Le type de python est-il un type?
Implémentation de réseaux neuronaux "flous" avec Chainer
Obtenez la valeur de la couche intermédiaire de NN
Un mémo expliquant la spécification de l'axe de l'axe
Obtenez le nom de fichier du répertoire (glob)
L'histoire du traitement A du blackjack (python)
Ajouter une couche à l'aide du backend Keras
Visualisez les données d'exportation du journal Piyo
Notez l'achèvement d'une commande chronophage
Le résultat était meilleur lorsque les données d'apprentissage du mini-lot ont été faites un hybride de fixe et aléatoire avec un réseau de neurones.
Python vs Ruby "Deep Learning from scratch" Chapitre 3 Implémentation d'un réseau neuronal à 3 couches
Expérimentez avec divers algorithmes d'optimisation sur le réseau neuronal
Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Récupérer l'appelant d'une fonction en Python
Vérification de la normalisation des lots avec un réseau neuronal multicouche
Copiez la liste en Python
Trouvez le nombre de jours dans un mois
Écrire une note sur la version python de python virtualenv
Lignes directrices pour la conception de la couche de sortie des réseaux de neurones
Calculer la probabilité de valeurs aberrantes sur les moustaches de la boîte
J'ai couru le réseau neuronal sur le FPGA réel
[Python] Une compréhension approximative du module de journalisation
Sortie sous la forme d'un tableau python
Reconnaissance des nombres manuscrits par un réseau neuronal multicouche
Visualisez le comportement de l'algorithme de tri avec matplotlib
L'histoire de la création d'un générateur d'icônes mel
Prise en compte des forces et faiblesses de Python
J'ai couru le tutoriel TensorFlow avec des commentaires (premier réseau de neurones: le début du problème de classification)
Réseau neuronal paramétrique