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

gpu GeForce GTX 1070
os ubuntu16.04
CUDA 8.0
cudnn 6.0
Keras 2.0.8

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.

Pomme
Orange

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%.

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