[PYTHON] Lassen Sie uns ein Bilderkennungsmodell mit Ihren eigenen Daten erstellen und spielen!
Einführung
Früher wollte ich Bilderkennung mit meinen eigenen Daten anstelle von MNIST durchführen, aber das ist ziemlich gut! !! Es gibt nur wenige solche Artikel, und selbst wenn ich das kann, ist die einzige Ausgabe die richtige Antwortrate, daher konnte ich das Experiment nicht durchführen, daher möchte ich es zusammenfassen. Wenn ich es mir leisten kann, möchte ich bis zur Erstellung einer Bilderkennungsanwendung schreiben, indem ich sie in einer Webanwendung installiere.
Ich denke, es gibt einige Dinge, die nicht erreicht werden können, aber ich würde es begrüßen, wenn Sie auf Fehler hinweisen könnten.
Rauer Fluss, was Sie tun können
Wir verwenden CNN, das die Grundlage für neuere Bilderkennungsmethoden bildet. Erstellen Sie ein Modell, das das von Ihnen erstellte Bild lernen und erkennen, die trainierten Daten ausgeben und mit einem anderen Code lesen kann, damit Sie damit spielen können. Dieses Mal werde ich ein Programm erstellen, um bei mir zu Hause zwischen einer dreihaarigen und einer weißen Katze zu unterscheiden.
Umgebung
- win10
- python 3.7.3
- numpy
- Pillow 6.1.0
- tensorflow==1.13.1
- keras==2.1.2
- sklearn
Code
Der gesamte Code ist auch auf github zu finden. Laden Sie ihn daher von dort herunter.
Teil 1: Datenaufbereitung & Auffüllen
Bereiten Sie zuerst die Daten vor. Hier ist es sehr einfach, Sie speichern nur die gesammelten Bilder in Ordnern. (Trennen Sie die Dateien nach dem, was Sie hier unterscheiden möchten. Der Siro und das Mikrofon im Bild unten sind identisch.)
Erstellen Sie außerdem einen Ordner test_img, um die Bilder zu speichern, die Sie vorhersagen möchten.
Als nächstes werden wir die Daten aufblasen und einen Datensatz erstellen. Das Aufblasen von Daten bedeutet, dass es sehr schwierig ist, genügend Daten von Hand zu erfassen (dies ist problematisch). Sobald Sie einige Bilder erfasst haben, können Sie die Bilder drehen oder invertieren, um den Datensatz aufzublasen und zu lernen. Es wird ein Gerät zu tun sein. Der folgende Code ist aug.py im obigen Bild.
aug.py
from PIL import Image
import os, glob
import numpy as np
from keras.utils import np_utils
from sklearn import model_selection
from sklearn.model_selection import train_test_split
classes = ["mike","siro"]####Geben Sie hier das Etikett ein, das Sie identifizieren möchten
num_classes = len(classes)
image_size = 128
#Datensatzverzeichnis
#Das Mikrofon, das ich früher gemacht habe,Geben Sie den Pfad kurz vor dem Siro-Ordner ein
datadir='./'
#Bilder laden
X = []
Y = []
for index, classlabel in enumerate(classes):
photos_dir = datadir+ classlabel
files = glob.glob(photos_dir + "/*.jpg ")
for i, file in enumerate(files):
image = Image.open(file)
image = image.convert("RGB")
image = image.resize((image_size, image_size))
#image.save("./test/{}{}.jpg ".format(classlabel,i))
data = np.asarray(image)
for angle in range(-20, 20, 5):##5
#Drehung
img_r = image.rotate(angle)
data = np.asarray(img_r)
X.append(data)
Y.append(index)
#Umkehren
img_trans = image.transpose(Image.FLIP_LEFT_RIGHT)
data = np.asarray(img_trans)
X.append(data)
Y.append(index)
X = np.array(X)
Y = np.array(Y)
#Zu 20% Testdaten
(X_train, X_test, y_train, y_test) = train_test_split(X, Y,test_size=0.2)
#Normalisierung
X_train = X_train.astype("float") / 255
X_test = X_test.astype("float") / 255
#Konvertieren Sie den Lehrerdatentyp
y_train = np_utils.to_categorical(y_train,num_classes)
y_test = np_utils.to_categorical(y_test, num_classes)
#X_train, X_test, y_train, y_test = model_selection.train_test_split(X, Y)
xy = (X_train, X_test, y_train, y_test)
np.save("./dataset.npy", xy)
Wenn die Ausführung abgeschlossen ist, sollte sich eine Datei mit dem Namen dataset.npy im selben Verzeichnis befinden. Dies ist der diesmal verwendete Datensatz.
Teil 2: Lernen
Lesen Sie den zuvor erstellten Datensatz und beginnen Sie schließlich mit dem Lernen. Der folgende Code entspricht CNN.py im ersten Bild.
CNN.py
import keras
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.layers import BatchNormalization
from keras.optimizers import SGD
import numpy as np
from sklearn.model_selection import train_test_split
from PIL import Image
import glob
from PIL import Image
import matplotlib.pyplot as plt
import os
from keras.callbacks import TensorBoard,ModelCheckpoint
#Hyperparameter
hp1 = {}
hp1['class_num'] = 2 #Anzahl der Klassen (diesmal Mikrofon,Weil es 2 Klassen von Siro sind 2)
hp1['batch_size'] = 64 #Chargengröße#####32
hp1['epoch'] = 20 #Anzahl der Epochen
#Laden des Datensatzes
##Laden Sie hier den im vorherigen Kapitel erstellten Datensatz
X_train, X_test, y_train, y_test = np.load("./dataset.npy", allow_pickle=True)
#Eingabegröße
input_shape=X_train.shape[1:]
#Erstellen Sie CNN
def CNN(input_shape):
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',input_shape=input_shape))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(BatchNormalization())
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(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(128, (3, 3)))
model.add(BatchNormalization())
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(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(hp1['class_num']))
model.add(Activation('softmax'))
return model
#Wählen Sie ein Modell
model=CNN(input_shape)
#kompilieren
model.compile(loss='categorical_crossentropy',optimizer='SGD',metrics=['accuracy'])
#Datenaufzeichnung
log_dir = os.path.join(os.path.dirname(__file__), "logdir")
model_file_name="model_file.hdf5"
#Ausbildung
history = model.fit(
X_train, y_train,
epochs=hp1['epoch'],
validation_split = 0.2,
callbacks=[
TensorBoard(log_dir=log_dir),
ModelCheckpoint(os.path.join(log_dir,model_file_name),save_best_only=True)
]
)
#Auswertung&Ausgabe des Bewertungsergebnisses
loss,accuracy = model.evaluate(X_test, y_test, batch_size=hp1['batch_size'])
Es wird einige Zeit dauern, hier zu lernen. Ich denke, es ist eine durcheinandergebrachte Warnung, aber keine Sorge ... Wenn die Ausführung abgeschlossen ist, wird ein Ordner namens logdir erstellt, in dem sich eine Datei mit dem Namen ** model_file.hdf5 ** befinden sollte. Dies ist das wichtigste und geschulte Modell.
Teil 3: Erkennungsergebnisse vorhersagen und spielen
Spielen Sie zum Schluss mit dem trainierten Modell. Ich denke, der Ordner sieht jetzt so aus.
Bitte fügen Sie das Bild, das Sie vorhersagen möchten, in dieses test_img ein.
Lesen Sie die Ausgabe ** model_file.hdf5 ** früher und machen Sie eine Vorhersage. Der folgende Code lautet pred.py.
predict.py
from pathlib import Path
import numpy as np
from PIL import Image
from keras.models import load_model
import glob
##### mike=0,siro=1 ######
###Geladenes trainiertes Modell laden
model_path = "./logdir/model_file.hdf5"
##Der Speicherort der Daten, die Sie vorhersagen möchten
images_folder = "./test_img"
classes = ["mike","siro"]
# load model
model = load_model(model_path)
#image_size=100
image_size=128
X = []
dir = images_folder
#Überprüfen Sie den Pfad
#print(dir)
files = glob.glob(dir + "/*.jpg ")
for i, file in enumerate(files):
image = Image.open(file)
image = image.convert("RGB")
image = image.resize((image_size, image_size))
data = np.asarray(image)
X.append(data)
X = np.array(X)
#Normalisierung(0-1)
X = X.astype('float32')
X = X / 255.0
#print(len(files))
##softmax
for w in range(len(files)):
result = model.predict([X])[w]
predicted = result.argmax()
percentage = int(result[predicted] * 100)
print(files[w].split('\\')[-1])
print("{0}({1} %)".format(classes[predicted],percentage))
Diesmal habe ich versucht, ein solches Bild einzugeben. (süß)
Ich denke, das Ausführungsergebnis von Predict.py wird so aussehen.
Sie können vorhersagen, dass es sich sicher um eine weiße Katze handelt! !!
Zusammenfassung
Wie war das? ?? Ich hoffe du kannst sicher spielen. Wenn Sie mit der Entwicklung von hier aus eine Bilderkennungsanwendung erstellen möchten, können Sie eine Anwendung erstellen, die Vorhersagen zurückgibt, wenn Sie die trainierten Modelle model_file.hdf5 und Predict.py auf dem Server haben.
Als Referenz ist die Webanwendung zur Bilderkennung, die ich und andere Mitglieder in der Vergangenheit bei Hackason erstellt und auf der Ausstellung für technische Bildung vorgestellt haben, hier.
Verweise
- Tiefes Lernen von Grund auf neu
- Intuitives Deep Learning
Recommended Posts