Dernière fois Créez un programme de reconnaissance d'image qui distingue les singes, les inoshi et les corbeaux en utilisant les données d'entraînement créées.

Qu'est-ce que keras

https://keras.io/ja/

Keras est une bibliothèque de réseau neuronal de haut niveau écrite en Python qui peut être exécutée sur TensorFlow, CNTK ou Theano.

Code source

importer

from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.utils import np_utils
import keras
import numpy as np

Fonction principale

Le flux général est le suivant:

Chargez le fichier ʻanimal.npy` précédemment enregistré
Transmettez les données d'entraînement à la fonction d'entraînement pour créer un modèle
Transmettez le modèle créé à la fonction d'évaluation pour vérifier l'exactitude de la classification.

classes = ["monkey", "boar", "crow"]
num_classes = len(classes)
image_size = 50

def main():
    X_train, X_test, y_train, y_test = np.load("./animal.npy", allow_pickle=True)
    X_train = X_train.astype("float") / 256
    X_test = X_test.astype("float") / 256
    y_train = np_utils.to_categorical(y_train, num_classes)
    y_test = np_utils.to_categorical(y_test, num_classes)

    model = model_train(X_train, y_train)
    model_eval(model, X_test, y_test)

-La raison pour laquelle «X_train» et «X_test» sont divisés par 256 est la normalisation (les données sont comprises entre 0 et 1).

・ To_categorical a un tableau de [0, 1, 2]

[[1, 0, 0]
 [0, 1, 0]
 [0, 0, 1]]

Donc, convertissez en un tableau qui contient 1 uniquement dans l'index de la bonne réponse et 0 dans d'autres endroits.

Entraînement

Reportez-vous à la 34ème ligne et après du code suivant Référence: https://github.com/keras-team/keras/blob/master/examples/cifar10_cnn.py

def model_train(X, y):
    model = Sequential()
    model.add(Conv2D(32, (3,3), padding='same', input_shape=X.shape[1:]))
    model.add(Activation('relu'))
    model.add(Conv2D(32, (3,3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2,2)))
    model.add(Dropout(0.25))

    model.add(Conv2D(64, (3,3), padding='same'))
    model.add(Activation('relu'))
    model.add(Conv2D(64, (3,3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2,2)))
    model.add(Dropout(0.25))

    model.add(Flatten())
    model.add(Dense(512))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(3))
    model.add(Activation('softmax'))

    opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)

    model.compile(loss='categorical_crossentropy',
                    optimizer=opt, metrics=['accuracy'])

    model.fit(X, y, batch_size=32, epochs=100)

    #Enregistrer le modèle
    model.save("./animal_cnn.h5")

    return model

model = Sequential() Créer un objet modèle

model.add(Conv2D(...)) Ajouter un calque

model.add(Activation('relu')) Ajouter un calque qui utilise "ReLU (Rectified Linear Unit)" comme fonction d'activation

model.add(MaxPooling2D(pool_size=(2,2))) Ajouter une couche pour une mise en commun maximale (diviser l'entrée en zones prédéterminées et afficher la valeur maximale de chaque zone)

model.add(Dropout(0.25)) Jeter 25% (quoi?) Pour éliminer le biais des données

opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6) Déclaration d'optimisation. Avec la méthode «optimizers.rmsprop », le taux d'apprentissage est de 0,0001, et le taux d'abaissement du taux d'apprentissage est de 0,000001 à chaque fois.

model.compile() Compilation du modèle.

model.fit(X, y, batch_size=32, epochs=100) Entraînez-vous avec «X» et «y». batch_size est le nombre de données utilisées dans une formation. ʻEpochs` Combien de formations faites-vous?

Évaluation des résultats de la formation

Validez le modèle créé par la méthode ʻevaluate`.

def model_eval(model, X, y):
    scores = model.evaluate(X, y, verbose=1)
    print('test Loss: ', scores[0])
    print('test Accuracy: ', scores[1])