[PYTHON] 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 **
** Sortie de la couche de convolution 1 **
** Sortie de la couche de convolution 2 **
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