[Pour les débutants en apprentissage profond] Implémentation d'une classification binaire simple par couplage complet à l'aide de Keras

Aperçu

Avec l'avènement de l'apprentissage en profondeur, il est devenu possible d'effectuer des tâches d'IA avec une meilleure précision que l'apprentissage automatique conventionnel. Cependant, l'apprentissage en profondeur est encore au stade de développement et il n'existe aucune méthode établie pour le faire. De plus, comme il est au stade de la recherche, il existe de nombreuses situations où la mise en œuvre et le contrôle sont compliqués.

Cette fois, je vais introduire une classification binaire simple dans le but de rendre la mise en œuvre aussi simple que possible et d'essayer de faire progresser l'apprentissage en profondeur.

Cette fois, nous utiliserons l'apprentissage profond pour classer les deux images de pommes et d'oranges. Pour le framework DL, nous avons adopté Keras, qui est difficile à régler mais facile à utiliser.

environnement

Structure du répertoire

Préparer un module d'exécution et un répertoire pour stocker les données

├── data 
└── exe.py

Dans le répertoire de données, préparez le train de données d'entraînement et le test de données de test, et stockez les images de pommes et d'oranges, respectivement.

├── test
│   ├── 00_apple
│   └── 01_orange
└── train
    ├── 00_apple
    └── 01_orange

Les données

Cela ressemble à ceci dans chaque répertoire.

Apprentissage

from keras.utils.np_utils import to_categorical
from keras.optimizers import Adagrad
from keras.optimizers import Adam
import numpy as np
from PIL import Image
import os

#Lire les données des enseignants

train_path="./data/train/"
test_path="./data/test/"

xsize=25
ysize=25

image_list = []
label_list = []


for dataset_name in os.listdir(train_path):

    dataset_path = train_path + dataset_name
    label = 0

    if dataset_name == "00_apple":
        label = 0
    elif dataset_name == "01_orange":
        label = 1

    for file_name in sorted(os.listdir(dataset_path)):
        label_list.append(label)
        file_path = dataset_path + "/" + file_name
        image = np.array(Image.open(file_path).resize((xsize, ysize)))
        print(file_path)

        #Convertir par ordre RVB,[[Tableau rouge],[Tableau vert],[Tableau bleu]]
        image = image.transpose(2, 0, 1)

        #Convertir en un tableau unidimensionnel(25*25*3) Red,Green,Les éléments de Blue sont disposés dans l'ordre.
        image = image.reshape(1, image.shape[0] * image.shape[1] * image.shape[2]).astype("float32")[0]

        #Convertir dans la plage de 0 à 1
        image_list.append(image / 255.)


#conversion numpy.
X = np.array(image_list)

# label=0 -> [1,0], label=1 -> [0,1]Conversion en
Y = to_categorical(label_list)

#Définition du modèle
model = Sequential()
model.add(Dense(200, input_dim=xsize*ysize*3))
model.add(Activation("relu"))
model.add(Dropout(0.2))

model.add(Dense(200))
model.add(Activation("relu"))
model.add(Dropout(0.2))

model.add(Dense(2))
model.add(Activation("softmax"))

model.compile(loss="categorical_crossentropy", optimizer=Adam(lr=0.001), metrics=["accuracy"])
model.summary()

#Apprentissage
model.fit(X, Y, nb_epoch=1000, batch_size=100, validation_split=0.1)

CNN est souvent utilisé pour classer les images, mais par souci de simplicité, seule la combinaison complète est utilisée cette fois. De plus, lors de l'extraction de caractéristiques de forme à partir d'une image, elle est souvent mise en échelle de gris afin que les informations inutiles ne soient pas incluses, mais il est jugé que les informations de couleur sont importantes car il s'agit d'une classification des pommes et des oranges. Cependant, toutes les informations RVB sont transmises à l'entrée du réseau neuronal sans échelle de gris.

inférence

#inférence
total = 0.
ok_count = 0.

for testset_name in os.listdir(test_path):

    testset_path = test_path + testset_name

    label = -1

    if testset_name == "00_apple":
        label = 0
    elif testset_name == "01_orange":
        label = 1
    else:
        print("error : label not exist")
        exit()

    for file_name in os.listdir(testset_path):
        label_list.append(label)
        file_path = testset_path + "/" + file_name
        image = np.array(Image.open(file_path).resize((25, 25)))
        print(file_path)
        image = image.transpose(2, 0, 1)
        image = image.reshape(1, image.shape[0] * image.shape[1] * image.shape[2]).astype("float32")[0]
        result = model.predict_classes(np.array([image / 255.]))
        print("label:", label, "result:", result[0])

        total += 1.

        if label == result[0]:
            ok_count += 1



print("accuracy: ", ok_count / total * 100, "%")

résultat

accuracy:  100.0 %

Même si l'apprentissage en profondeur est très précis, le taux de précision n'est pas tout à fait de 100%. Cependant, cette fois, il s'agissait d'une simple classification des pommes et des oranges, donc le taux de réponse correcte était de 100%.

Recommended Posts

[Pour les débutants en apprentissage profond] Implémentation d'une classification binaire simple par couplage complet à l'aide de Keras
Détection d'anomalies par encodeur automatique à l'aide de keras [Exemple d'implémentation pour les débutants]
Exemple d'implémentation d'un réseau de génération hostile (GAN) par Keras
Deep learning 2 appris par l'implémentation (classification d'images)
Apprentissage parallèle du deep learning par Keras et Kubernetes
Implémentation du modèle Deep Learning pour la reconnaissance d'images
Apprentissage profond appris par mise en œuvre (segmentation) ~ Mise en œuvre de SegNet ~
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
[Apprentissage automatique Python] Recommandation d'utilisation de Spyder pour les débutants (à partir d'août 2020)
Apprentissage profond appris par l'implémentation 1 (édition de retour)
Les débutants du Deep Learning ont essayé les prévisions météorologiques à partir d'images satellitaires météorologiques à l'aide de Keras
Othello-De la troisième ligne de "Implementation Deep Learning" (3)
Algorithme d'apprentissage automatique (implémentation de la classification multi-classes)
Implémentation et description à l'aide de XGBoost pour les débutants
Détection d'objets par apprentissage profond pour comprendre en profondeur par Keras
[Apprentissage en profondeur] Détection de visage Nogisaka ~ Pour les débutants ~
Othello-De la troisième ligne de "Implementation Deep Learning" (2)
[Pour les débutants en intelligence artificielle] Parcours d'apprentissage et de référence en apprentissage automatique / programmation en profondeur
[Super Introduction] Apprentissage automatique utilisant Python - De la construction d'environnement à l'implémentation de perceptron simple-
Un mémorandum de méthode souvent utilisé dans l'apprentissage automatique utilisant scikit-learn (pour les débutants)
Classification des images de guitare par apprentissage automatique Partie 1
Ordre d'étude recommandé pour les débutants en apprentissage automatique / apprentissage en profondeur
Apprentissage profond appris par la mise en œuvre ~ Détection d'anomalies (apprentissage sans enseignant) ~
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Classification des images de guitare par apprentissage automatique, partie 2
Techniques pour comprendre la base des décisions d'apprentissage en profondeur
Othello ~ De la troisième ligne de "Implementation Deep Learning" (4) [Fin]
[Linux] Principes de base de la configuration des autorisations par chmod pour les débutants
Mise en œuvre de l'apprentissage en série de Chainer à l'aide de mini-lots de longueur variable
Collecte et automatisation d'images érotiques à l'aide du deep learning