[PYTHON] [Maschinelles Lernen] Erstellen Sie ein Modell für maschinelles Lernen, indem Sie Transferlernen mit Ihrem eigenen Datensatz durchführen
1. Zuallererst
Frühere Artikel ( Scraping , Bildverarbeitung mit OpenCV ) führte ein, wie Sie Ihren eigenen Datensatz erstellen. In diesem Artikel möchte ich vorstellen, wie ein Modell für maschinelles Lernen erstellt wird, das den erstellten Datensatz verwendet, um Transferlernen durchzuführen und Japaner und Ausländer zu beurteilen.
2. Was ich diesmal machen möchte
Bereiten Sie den Datensatz vor, der zum Erstellen eines Modells für maschinelles Lernen erforderlich ist. ← Inhalt bis zum vorherigen Zeitpunkt ↓ ---------- Was in diesem Artikel von hier aus zu tun ist ---------- ↓ Erstellen Sie ein Modell für maschinelles Lernen mithilfe von Transferlernen. ↓ Verwenden Sie ein Modell für maschinelles Lernen, um Bilder von Japanern und Ausländern zu bestimmen.
3. Was ist Transferlernen?
Kurz gesagt, Transferlernen ist eine Modelllernmethode, mit der die Leistung von Modellen für maschinelles Lernen in kurzer Zeit verbessert werden kann.
Im Allgemeinen ist die Leistung (Genauigkeit) eines maschinellen Lernmodells besser, wenn die Schicht des maschinellen Lernmodells tief und breit ist.
Das Erstellen eines so umfassenden und umfassenden Modells für maschinelles Lernen von Grund auf erfordert jedoch eine enorme Menge an Zeit und Daten.
Daher besteht das Transferlernen darin, den anderen Teil als die vollständig verbundene Schicht des vorhandenen Hochleistungsmodells für maschinelles Lernen (VGG16 usw.) als Merkmalsextraktionsschicht zu verwenden und dann den Teil der vollständig verbundenen Schicht selbst zu erstellen und zu trainieren. ..
Im Vergleich zum Erstellen eines Modells für maschinelles Lernen von Grund auf erfordert das Transferlernen daher nur das Lernen der vollständig verbundenen Schicht, sodass es möglich ist, ein Modell für maschinelles Lernen mit guter Leistung in kurzer Zeit zu erstellen.
Quelle: "Was ist Transferlernen? Wie machen Sie das erwartete" Transferlernen "beim Deep Learning?
4. Quellcode
Der diesmal verwendete Quellcode ist unten dargestellt.
cnn.py
from keras.layers import Dense, Dropout, Flatten, Activation
from keras.layers import Conv2D, MaxPooling2D, Input, BatchNormalization
from keras.models import Sequential, load_model, Model
from keras.applications.vgg16 import VGG16
from keras.optimizers import SGD
from keras.preprocessing import image
import numpy as np
import matplotlib.pyplot as plt
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
epochs = 10
#Zeichnen Sie Genauigkeit und Verlust für jede Epoche in einem Diagramm
def show_graph(history):
# Setting Parameters
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
# 1) Accracy Plt
plt.plot(epochs, acc, 'bo', label='training acc')
plt.plot(epochs, val_acc, 'b', label='validation acc')
plt.title('Training and Validation acc')
plt.legend()
plt.figure()
# 2) Loss Plt
plt.plot(epochs, loss, 'bo', label='training loss')
plt.plot(epochs, val_loss, 'b', label='validation loss')
plt.title('Training and Validation loss')
plt.legend()
plt.show()
#Daten aus einem Datensatz abrufen
(X_train, y_train, X_test, y_test) = np.load('Datensatzpfad')
X_train = np.array(X_train)
X_train = X_train.astype('float32')
X_train /= 255
y_train = np.array(y_train)
X_test = np.array(X_test)
X_test = X_test.astype('float32')
X_test /= 255
y_test = np.array(y_test)
datagen = image.ImageDataGenerator(
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2
)
datagen.fit(X_train)
input_tensor = Input(shape=(64, 64, 3))
#Lesen Sie die VGG16-Daten
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)
top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(BatchNormalization())
top_model.add(Dropout(0.5))
top_model.add(Dense(2, activation='softmax'))
#vgg16 und top_Modelle verketten
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))
#Befestigen Sie die Gewichte bis zur 19. Ebene mit der for-Anweisung
for layer in model.layers[:19]:
layer.trainable = False
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=32),
steps_per_epoch=len(X_train)/32, epochs=epochs, validation_data=(X_test, y_test))
#Bewertung der Genauigkeit
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
Die diesmal aus dem Datensatz erfassten Daten sind (64 * 64) Farbbilddaten und deren Beschriftung. X_train und X_test sind Bilddaten und y_train und y_test sind Beschriftungen. Betrachtet man den Inhalt von X_train,
print(X_train.shape)
print(X_train[0])
(1547, 64, 64, 3)
[[[ 36 40 50]
[ 40 46 59]
[ 57 64 82]
...
[114 120 124]
[161 155 152]
[141 118 109]]
...
[[203 146 115]
[210 154 123]
[182 128 95]
...
[249 250 248]
[251 243 241]
[228 212 213]]]
Es sieht aus wie das. Mit anderen Worten, X_train enthält 1547 (64 * 64) Farbbilder. Außerdem ist der in X_train gespeicherte Wert ein 8-Bit-Integer-Typ ohne Vorzeichen von 0 bis 255. Wir teilen dies durch 255, um eine Zahl zwischen 0 und 1 zu erhalten, um die Lernkosten zu senken.
Wenn Sie die y_train-Daten auf die gleiche Weise überprüfen,
print(y_train.shape)
print(y_train[0])
(1547, 2)
[0 1]
Sie können sehen, dass die gleiche Anzahl von One-Hot-Vektoren wie X_train gespeichert ist.
Laden Sie dann das Modell VGG16. Informationen zum Laden des VGG16-Modells finden Sie in der Dokumentation zu Keras-Anwendungen . Dieses Mal werden 3 Argumente gesetzt. include_top gibt an, ob die drei vollständig verbundenen Schichten auf der Seite der Ausgangsschicht des Netzwerks eingeschlossen werden sollen. Dieses Mal werden wir Transferlernen durchführen, sodass wir nicht die vollständig verbundene Schicht von VGG16 benötigen. Daher ist es auf False gesetzt. Gewichte bestimmen das Gewicht von VGG16. Wenn es None ist, ist es zufällig, und wenn es "Imagenet" ist, ist es das trainierte Gewicht. input_tensor gibt die Größe des Eingabebildes an.
top_model ist der Teil der vollständig verbundenen Schicht, der nach VGG16 haftet. VGG16 und top_model sind in ein Modell namens model integriert. Und dieses Mal möchte ich das Gewicht von VGG16 verwenden, wie es im Bild gelernt wird, also schreibe ich den folgenden Code.
#Befestigen Sie die Gewichte bis zur 19. Ebene mit der for-Anweisung
for layer in model.layers[:19]:
layer.trainable = False
5. Verwenden Sie Google Colaboratory
Selbst wenn Sie sagen, dass Sie ein Modell für maschinelles Lernen durch Transferlernen erstellen, wird das Lernen einige Zeit dauern, wenn die Spezifikationen des von Ihnen verwendeten Computers niedrig sind, die Anzahl der Daten groß ist oder die Anzahl der Epochen groß ist. In einem solchen Fall erstellen wir ein Modell für maschinelles Lernen mit Google Colabratory. Google Colabratory ist eine von Google bereitgestellte Jupyter-Notebook-Umgebung. Der größte Vorteil dieses Dienstes besteht darin, dass er mithilfe der GPU mit hoher Geschwindigkeit verarbeitet werden kann. Ich denke, dass sich die Verarbeitungszeit je nach Vorhandensein oder Fehlen einer GPU um etwa das Zehnfache unterscheidet. Hier sind die Schritte, die Sie ausführen müssen, um den obigen Quellcode in Google Colaboratory auszuführen.
Öffnen Sie zuerst Google Colaboratory, geben Sie ihm einen Namen und ändern Sie dann die Einstellungen, um die GPU zu verwenden.
Um die GPU zu aktivieren, klicken Sie oben links unter dem Dateinamen auf die Schaltfläche "Bearbeiten-> Notebook-Einstellungen".
Dann erscheint der folgende Bildschirm, wählen Sie also "GPU".
Das Notebook ist jetzt bereit für die GPU.
Geben Sie dann den folgenden Code ein, um die Version von numpy zu ändern.
pip install numpy==1.16.1
Der Grund für das Schreiben dieses Codes besteht darin, Fehler beim Lesen des Datensatzes im obigen Quellcode zu vermeiden. Laden Sie dann den Datensatz auf Ihr Notizbuch hoch. Verknüpfen Sie zum Hochladen Google Colaboratory und laden Sie die hochgeladene Datei in Google Drive. Geben Sie den folgenden Code ein, damit es funktioniert.
from google.colab import drive
drive.mount('/content/gdrive')
Wenn Sie den Code eingeben, wird ein Bereich angezeigt, in dem Sie die URL und den Bestätigungscode eingeben können.
Wenn Sie auf den Link klicken und sich bei Google Drive anmelden, wird das Kennwort für die Authentifizierung angezeigt. Kopieren Sie es und geben Sie den Authentifizierungscode ein, um die Daten in Google Drive zu verwenden.
Die Verzeichnisstruktur auf dem Notebook lautet (./gdrive/MyDrive/).
Die in meinem Google Drive gespeicherten Dateien werden dort gespeichert.
6. Am Ende
Dieses Mal haben wir ein Modell für maschinelles Lernen erstellt, indem wir Transferlernen mit unserem eigenen Datensatz durchgeführt haben. Sogar ein Amateur kann beim maschinellen Lernen leicht Code schreiben, aber es kann das Verständnis des um diesen Betrag geschriebenen Codes schwächen. Daher halte ich es für wichtig, auf den Code zurückzublicken, den ich auf diese Weise geschrieben habe. Ich werde. Das nächste Mal werde ich das diesmal erstellte Modell des maschinellen Lernens verwenden, um eine Webanwendung zu erstellen, die die Gesichter von Japanern und Ausländern unterscheidet.
Verweise
・ Keras Documentatino-Anwendung ・ Verwendung von Google Colabratory ・ Ich habe versucht, die kostenlose GPU-Umgebung von Google Colaboratory zu verwenden ・ Was ist Transferlernen? Wie macht man das erwartete "Transferlernen" beim Deep Learning?
Recommended Posts