[PYTHON] Keras Multiklassenklassifikation Iris
Umgebung
- Tensorflow 2.3.0
- Google Colaboratory
Einführung
- (Achtung) Das Gewicht ist nicht der Inhalt der Klassifizierung mehrerer Klassen, sondern der Inhalt der Verwendung von tf.keras. --Erstellen Sie ein mehrschichtiges Perzeptron (MLP) mit Tensorflow-Keras
- Einfache Verwendung von tf.keras, Speichern des Modells und Laden des gespeicherten Modells ――Wenn ich Kaggle machte, überprüfte ich noch einmal, wie ich den Keras-Code lesen sollte, weil ich ihn brauchte.
Datensatz
--Überprüft anhand des an scikit-learn angehängten Iris-Pflanzendatensatzes
- Der Iris-Datensatz enthält drei Arten von Informationen (setosa, versicolor, virginica), sodass er für die Klassifizierung mehrerer Klassen verwendet werden kann.
Ganzer Quellcode
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from tensorflow.keras.utils import to_categorical
import tensorflow as tf
import matplotlib.pyplot as plt
#Lesen Sie den Iris-Datensatz
iris = load_iris()
#Trainingsdatensatz,In Testdaten unterteilt
data_X = iris.data
data_y = to_categorical(iris.target) # one-Hot-Codierung
train_X, test_X, train_y, test_y = train_test_split(data_X, data_y, test_size=0.3, random_state=0)
#Ein Modell bauen
model = tf.keras.models.Sequential([
tf.keras.layers.Input(4),
tf.keras.layers.Dense(100, activation='relu'),
tf.keras.layers.Dense(3, activation='softmax')
])
#Modell kompilieren
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
loss='categorical_crossentropy',
metrics=['accuracy'])
#Modelllernen
result = model.fit(train_X, train_y, batch_size=32, epochs=50, validation_data=(test_X, test_y), verbose=1)
#Genauigkeitsdiagramm
plt.figure()
plt.title('Accuracy')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.plot(result.history['accuracy'], label='train')
plt.plot(result.history['val_accuracy'], label='test')
plt.legend()
#Verlustplot
plt.figure()
plt.title('categorical_crossentropy Loss')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.plot(result.history['loss'], label='train')
plt.plot(result.history['val_loss'], label='test')
plt.legend()
plt.show()
# model.Verwenden Sie evaluieren, um den Fehler und die Genauigkeit des trainierten Modells abzurufen
train_score = model.evaluate(train_X, train_y)
test_score = model.evaluate(test_X, test_y)
print('Train loss:', train_score[0])
print('Train accuracy:', train_score[1])
print('Test loss:', test_score[0])
print('Test accuracy:', test_score[1])
#Überprüfen Sie das Ergebnis(predict)
pred_train = model.predict(train_X)
pred_test = model.predict(test_X)
pred_train = np.argmax(pred_train, axis=1)
pred_test = np.argmax(pred_test, axis=1)
print(pred_train)
print(np.argmax(train_y, axis=1))
print(pred_test)
print(np.argmax(test_y, axis=1))
Daten laden
--Laden Sie Irisdaten mit scikit-learn
from sklearn.datasets import load_iris
#Lesen Sie den Iris-Datensatz
iris = load_iris()
#Überprüfen Sie die Größe
(iris.data.shape), (iris.target.shape)
# ((150, 4), (150,))
print(iris.feature_names) #Überprüfen Sie das Etikett
print(iris.data) #Erklärende Variable
print(iris.target_names) #Überprüfen Sie das Etikett
print(iris.target) #Objektive Variable
#Überprüfen Sie den Dataset-Typ
type(iris.data)
type(iris.target)
# numpy.ndarray
--Erklärende Variable
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
[[5.1 3.5 1.4 0.2]
[4.9 3. 1.4 0.2]
[4.7 3.2 1.3 0.2]
[4.6 3.1 1.5 0.2]
[5. 3.6 1.4 0.2]...
- Objektive Variable
['setosa' 'versicolor' 'virginica']
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
Datenverarbeitung
- Konvertieren Sie die Zielvariable der Iris in eine One-Hot-Codierung, die mit einem neuronalen Netzwerk einfach zu handhaben ist
from tensorflow.keras.utils import to_categorical
# one-Hot-Codierung
data_y = to_categorical(iris.target)
# 0 => [1, 0, 0]
# 1 => [0, 1, 0]
# 2 => [0, 0, 1]
#Beispiel:Konvertieren Sie den Klassenvektor (Ganzzahl) in eine binäre Klassenmatrix
to_categorical(iris.target,
num_classes=None,
dtype='float32')
-
Siehe unten für Details https://www.tensorflow.org/api_docs/python/tf/keras/utils/to_categorical
-
Teilen Sie als nächstes den Datensatz in Trainingsdaten und Testdaten auf.
#Trainingsdatensatz,In Testdaten aufteilen
from sklearn.model_selection import train_test_split
data_X = iris.data
data_y = to_categorical(iris.target) # one-Hot-Codierung
train_X, test_X, train_y, test_y = train_test_split(data_X, data_y, test_size=0.3, random_state=0)
- test_size=0.3
- Unterteilt in 70% der Trainingsdaten und 30% der Testdaten --random_state Setzt einen zufälligen Startwert
Netzwerkarchitektur
- Eingabeschicht 4 Variablen --Mittelschicht 100 Variablen
- Ausgabeschicht 3 Variablen --Aktivierungsfunktion relu
- Verlustfunktion categoryical_crossentropy --Optimierungsfunktion Adam
import tensorflow as tf
#Ein Modell bauen
model = tf.keras.models.Sequential([
tf.keras.layers.Input(4),
tf.keras.layers.Dense(100, activation='relu'),
tf.keras.layers.Dense(3, activation='softmax')
])
#Modell kompilieren
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
loss='categorical_crossentropy',
metrics=['accuracy'])
#Modelllernen
result = model.fit(train_X, train_y, batch_size=32, epochs=50, validation_data=(test_X, test_y), verbose=1)
Epoch 1/50
4/4 [==============================] - 0s 36ms/step - loss: 1.0097 - accuracy: 0.5810 - val_loss: 0.7336 - val_accuracy: 0.6222
Epoch 2/50
4/4 [==============================] - 0s 6ms/step - loss: 0.7082 - accuracy: 0.7048 - val_loss: 0.6553 - val_accuracy: 0.6000
Epoch 3/50
4/4 [==============================] - 0s 5ms/step - loss: 0.5494 - accuracy: 0.7905 - val_loss: 0.4738 - val_accuracy: 0.9111
- Keine Ausgabe von Zwischenergebnissen durch Setzen von verbose = 0 in model.fit
Modellbewertung
# model.Verwenden Sie evaluieren, um den Fehler und die Genauigkeit des trainierten Modells abzurufen
train_score = model.evaluate(train_X, train_y)
test_score = model.evaluate(test_X, test_y)
print('Train loss:', train_score[0])
print('Train accuracy:', train_score[1])
print('Test loss:', test_score[0])
print('Test accuracy:', test_score[1])
4/4 [==============================] - 0s 2ms/step - loss: 0.0649 - accuracy: 0.9714
2/2 [==============================] - 0s 2ms/step - loss: 0.1223 - accuracy: 0.9778
Train loss: 0.06492960453033447
Train accuracy: 0.9714285731315613
Test loss: 0.12225695699453354
Test accuracy: 0.9777777791023254
#Überprüfen Sie das Ergebnis(predict)
pred_train = model.predict(train_X)
pred_test = model.predict(test_X)
pred_train = np.argmax(pred_train, axis=1)
pred_test = np.argmax(pred_test, axis=1)
print(pred_train)
print(np.argmax(train_y, axis=1))
print(pred_test)
print(np.argmax(test_y, axis=1))
[1 2 2 2 2 1 2 1 1 2 1 2 2 1 2 1 0 2 1 1 1 1 2 0 0 2 1 0 0 1 0 2 1 0 1 2 1
0 2 2 2 2 0 0 2 2 0 2 0 2 2 0 0 1 0 0 0 1 2 2 0 0 0 1 1 0 0 1 0 2 1 2 1 0
2 0 2 0 0 2 0 2 1 1 1 2 2 1 1 0 1 2 2 0 1 1 1 1 0 0 0 2 1 2 0]
[1 2 2 2 2 1 2 1 1 2 2 2 2 1 2 1 0 2 1 1 1 1 2 0 0 2 1 0 0 1 0 2 1 0 1 2 1
0 2 2 2 2 0 0 2 2 0 2 0 2 2 0 0 2 0 0 0 1 2 2 0 0 0 1 1 0 0 1 0 2 1 2 1 0
2 0 2 0 0 2 0 2 1 1 1 2 2 1 1 0 1 2 2 0 1 1 1 1 0 0 0 2 1 2 0]
[2 1 0 2 0 2 0 1 1 1 2 1 1 1 1 0 1 1 0 0 2 1 0 0 2 0 0 1 1 0 2 1 0 2 2 1 0
2 1 1 2 0 2 0 0]
[2 1 0 2 0 2 0 1 1 1 2 1 1 1 1 0 1 1 0 0 2 1 0 0 2 0 0 1 1 0 2 1 0 2 2 1 0
1 1 1 2 0 2 0 0]
Modell speichern
#Modell als JSON-Datei speichern
#Sparen Sie Gewicht als hdf5
config = model.to_json()
with open('model.json','w') as file:
file.write(config)
model.save_weights('weights.hdf5')
Modell laden
with open('model.json','r') as file:
model_json = file.read()
model = tf.keras.models.model_from_json(model_json)
model.load_weights('weights.hdf5')
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
loss='categorical_crossentropy',
metrics=['accuracy'])
train_score = model.evaluate(train_X, train_y)
test_score = model.evaluate(test_X, test_y)
print('Train loss:', train_score[0])
print('Train accuracy:', train_score[1])
print('Test loss:', test_score[0])
print('Test accuracy:', test_score[1])
4/4 [==============================] - 0s 2ms/step - loss: 0.0649 - accuracy: 0.9714
2/2 [==============================] - 0s 2ms/step - loss: 0.1223 - accuracy: 0.9778
Train loss: 0.06492960453033447
Train accuracy: 0.9714285731315613
Test loss: 0.12225695699453354
Test accuracy: 0.9777777791023254
- Weitere Informationen zu tf.keras.models.model_from_json finden Sie weiter unten
https://www.tensorflow.org/api_docs/python/tf/keras/models/model_from_json
Verweise
- https://snova301.hatenablog.com/entry/2018/10/29/175028
- https://aidiary.hatenablog.com/entry/20161108/1478609028
Ende (Um den Inhalt der Daten zu verstehen)
- Versuchen Sie es mit Pandas
- Versuchen Sie es mit Seaborn
import pandas as pd
import seaborn as sns
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['target'] = iris.target
df.loc[df['target'] == 0, 'target'] = "setosa"
df.loc[df['target'] == 1, 'target'] = "versicolor"
df.loc[df['target'] == 2, 'target'] = "virginica"
df.head(2)
| sepal length (cm) | sepal width (cm) | petal length (cm) | petal width (cm) | target |
|---|---|---|---|---|
| 5.1 | 3.5 | 1.4 | 0.2 | setosa |
| 4.9 | 3.0 | 1.4 | 0.2 | setosa |
sns.pairplot(df, hue="target")
