Python: Geschlechtsidentifikation (Entwicklung von Deep Learning) Teil 2
CNN Zuerst ein kurzer Rückblick
Modelldefinition
Die Definition des Modells durch Keras 'sequentielles Modell lautet wie folgt.
model = Sequential()
model.add(Schicht 1)
model.add(Schicht 2)
︙
Jede Ebene ist wie im folgenden Beispiel definiert.
#Vollständig verbundene Schicht
Dense(units, input_dim=784)
#Faltschicht
Conv2D(filters = 32, kernel_size=(2, 2), strides=(1, 1), padding="same", input_shape=(28, 28, 3))
#Pooling-Schicht
MaxPooling2D(pool_size=(2, 2), strides=None)
#Ebene abflachen
Flatten()
Die Aktivierungsfunktion wird wie im folgenden Beispiel wie jede Schicht behandelt.
model.add(Activation('sigmoid'))
Zu den Zeichenfolgen für die Aktivierung gehören'igmoid ',' relu 'und'oftmax'.
Wenn ich ein Modell schreibe, sieht es so aus.
from keras.utils.vis_utils import plot_model
from keras.layers import Activation, Conv2D, Dense, Flatten, MaxPooling2D
from keras.models import Sequential
#---------------------------
model = Sequential()
model.add(Conv2D(input_shape=(32, 32, 3), filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('sigmoid'))
model.add(Dense(128))
model.add(Activation('sigmoid'))
model.add(Dense(10))
model.add(Activation('softmax'))
#---------------------------
#Geben Sie die Struktur des Modells aus
model.summary()
Modellbetrieb
Nachdem Sie das Modell definiert haben, wie Sie die Lernrate ändern und was Sie mit der Verlustfunktion tun sollen Kompilieren Sie, indem Sie den anzuzeigenden Genauigkeitsindex angeben.
model.compile(optimizer='sgd', loss='mean_squared_error', metrics=['accuracy'])
Das Training des Modells wird wie folgt durchgeführt.
model.fit(X_train, y_train, batch_size=32, epochs=10)
Die Vorhersage unter Verwendung des Modells erfolgt wie folgt.
pred = np.argmax(model.predict(data[0]))
Klicken Sie hier für ein Codebeispiel
import matplotlib.pyplot as plt
import numpy as np
from keras.utils.vis_utils import plot_model
from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input, Conv2D, MaxPooling2D, Activation
from keras.models import Model, Sequential
from keras.utils.np_utils import to_categorical
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train[:1000]
X_test = X_test[:1000]
y_train = to_categorical(y_train)[:1000]
y_test = to_categorical(y_test)[:1000]
model = Sequential()
model.add(Conv2D(input_shape=(32, 32, 3), filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('sigmoid'))
model.add(Dense(128))
model.add(Activation('sigmoid'))
model.add(Dense(10))
model.add(Activation('softmax'))
#---------------------------
model.compile(optimizer='sgd', loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=100, epochs=1)
#---------------------------
for i in range(1):
x = X_test[i]
plt.imshow(x)
plt.show()
pred = np.argmax(model.predict(x.reshape(1,32,32,3)))
print(pred)
Lernen übertragen
#Hier wird das Transferlernen mit VGG16 durchgeführt. Erstellen Sie zunächst eine Instanz des VGG-Modells.
from keras.applications.vgg16 import VGG16
input_tensor = Input(shape=(32, 32, 3))
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)
Geben Sie das Eingabeformular als input_tersor an.
setze include_top auf false Verwenden Sie nur den Feature-Extraktionsteil von VGG Nachfolgende Modelle werden mit dem von Ihnen erstellten Modell kombiniert.
Hinzufügen einer weiteren Ebene nach dem Feature-Extraktionsteil Definieren Sie im Voraus ein anderes Modell als VGG (in diesem Fall top_model) und kombinieren Sie sie wie folgt.
top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dense(10, activation='softmax'))
#Eingabe ist vgg.input,Die Ausgabe ist, top_Modell mit vgg16 Ausgabe
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))
Das Gewicht des Feature-Extraktionsteils von vgg16 wird beim Aktualisieren reduziert. Korrigieren Sie es daher wie folgt.
#Bis zur 16. Modellschicht ist ein vgg-Modell
for layer in model.layers[:15]:
layer.trainable = False
Kompilieren und Lernen kann auf die gleiche Weise erfolgen, jedoch bei der Feinabstimmung (Feineinstellung) Die Optimierung sollte in SGD erfolgen.
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
Klicken Sie hier für ein Codebeispiel
import matplotlib.pyplot as plt
import numpy as np
from keras.utils.vis_utils import plot_model
from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input
from keras.models import Model, Sequential
from keras.utils.np_utils import to_categorical
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train[:1000]
X_test = X_test[:1000]
y_train = to_categorical(y_train)[:1000]
y_test = to_categorical(y_test)[:1000]
#Erstellen einer Instanz von vgg16
#---------------------------
input_tensor = Input(shape=(32, 32, 3))
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(Dense(10, activation='softmax'))
#Modellverkettung
#---------------------------
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))
#---------------------------
#Festes Gewicht von vgg16
#---------------------------
for layer in model.layers[:15]:
layer.trainable = False
#---------------------------
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=100, epochs=1)
for i in range(1):
x = X_test[i]
plt.imshow(x)
plt.show()
pred = np.argmax(model.predict(x.reshape(1,32,32,3)))
print(pred)
Techniken zur Verbesserung der Genauigkeit
Beim Training eines neuronalen Netzmodells Training (Überanpassung), das nur für Trainingsdaten gilt, findet häufig statt.
Hier verwenden wir eine Methode namens Dropout, bei der Eingabedaten zufällig entfernt (mit 0 überschrieben) werden. Verhindert Überanpassung.
Aussetzer machen neuronale Netze unabhängig von der Anwesenheit bestimmter Neuronen Sie lernen allgemeinere Funktionen kennen (die nicht nur auf Trainingsdaten beruhen).
Aussetzer können wie normale Ebenen verwendet werden.
model.add(Dropout(rate=0.5))
rate ist die Rate, mit der die Eingabeeinheit gelöscht wird (überschrieben mit 0).
Darüber hinaus kann Keras die Klassifizierungsgenauigkeit eines Modells wie folgt überprüfen.
score = model.evaluate(X_test, y_test)
X_test und y_test sind Eingabedaten und Lehrerdaten für Bewertungsdaten.
Klicken Sie hier für ein Codebeispiel
import matplotlib.pyplot as plt
import numpy as np
from keras.utils.vis_utils import plot_model
from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input
from keras.models import Model, Sequential
from keras.utils.np_utils import to_categorical
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train[:1000]
X_test = X_test[:1000]
y_train = to_categorical(y_train)[:1000]
y_test = to_categorical(y_test)[:1000]
#Erstellen einer Instanz von vgg16
input_tensor = Input(shape=(32, 32, 3))
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'))
#Aussteigen
#---------------------------
top_model.add(Dropout(rate=0.5))
#---------------------------
top_model.add(Dense(10, activation='softmax'))
#Modellverkettung
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))
#Festes Gewicht von vgg16
for layer in model.layers[:15]:
layer.trainable = False
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
model.summary()
#Erwerb des Lernprozesses
history = model.fit(X_train, y_train, batch_size=100, epochs=1, validation_data=(X_test, y_test))
Zusammenfassung
Lassen Sie uns das Cifar 10-Klassifizierungsmodell von CNN implementieren.
import keras
from keras.datasets import cifar10
from keras.layers import Activation, Conv2D, Dense, Dropout, Flatten, MaxPooling2D
from keras.models import Sequential, load_model
from keras.utils.np_utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt
#Lade Daten
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
#Modelldefinition
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',
input_shape=X_train.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(10))
model.add(Activation('softmax'))
#kompilieren
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
# Let's train the model using RMSprop
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
model.summary()
#Lernen
model.fit(X_train, y_train, batch_size=32, epochs=1)
#Bewertung der Genauigkeit
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
#Datenvisualisierung (erste 10 Blatt Testdaten)
for i in range(10):
plt.subplot(1, 10, i+1)
plt.imshow(X_test[i])
plt.show()
#Vorhersage (erste 10 Blatt Testdaten)
pred = np.argmax(model.predict(X_test[0:10]), axis=1)
print(pred)
Recommended Posts