1. Bildklassifikation
import tensorflow as tf
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.utils import to_categorical
# Laden des CIFAR-10-Datensatzes
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
# Vorverarbeitung der Daten
X_train, X_test = X_train / 255.0, X_test / 255.0
y_train, y_test = to_categorical(y_train, 10), to_categorical(y_test, 10)
# Erstellen des Modells
model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D((2, 2)),
Flatten(),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])
# Kompilieren des Modells
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Training des Modells
model.fit(X_train, y_train, epochs=10, batch_size=64, validation_data=(X_test, y_test))
# Evaluierung des Modells
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f'Testgenauigkeit: {test_acc}')
Ausgabe:
Testgenauigkeit: 0.72In dieser Fallstudie haben wir ein Convolutional Neural Network (CNN) erstellt, das den CIFAR-10-Datensatz klassifiziert. Das Modell wurde trainiert und auf den Testdaten evaluiert.
2. Textklassifikation
Textklassifikation ist eine häufige Aufgabe in der Verarbeitung natürlicher Sprache (NLP). In dieser Fallstudie verwenden wir Keras, um ein Modell zur Klassifikation von Texten zu erstellen. Wir verwenden den IMDB-Datensatz, der 50.000 Filmrezensionen mit positiven und negativen Bewertungen enthält.
Beispiel:
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
# Laden des IMDB-Datensatzes
vocab_size = 10000
maxlen = 200
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=vocab_size)
# Vorverarbeitung der Daten
X_train = pad_sequences(X_train, maxlen=maxlen)
X_test = pad_sequences(X_test, maxlen=maxlen)
# Erstellen des Modells
model = Sequential([
Embedding(vocab_size, 128, input_length=maxlen),
LSTM(64),
Dense(1, activation='sigmoid')
])
# Kompilieren des Modells
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Training des Modells
model.fit(X_train, y_train, epochs=10, batch_size=64, validation_data=(X_test, y_test))
# Evaluierung des Modells
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f'Testgenauigkeit: {test_acc}')
Ausgabe:
Testgenauigkeit: 0.86In dieser Fallstudie haben wir ein LSTM-Modell erstellt, das den IMDB-Datensatz klassifiziert. Das Modell wurde trainiert und auf den Testdaten evaluiert.
3. Zeitreihenvorhersage
Die Vorhersage von Zeitreihen ist eine häufige Aufgabe im Bereich des maschinellen Lernens. In dieser Fallstudie verwenden wir Keras, um ein Modell zur Vorhersage von Zeitreihendaten zu erstellen. Wir verwenden synthetische Daten zur Demonstration.
Beispiel:
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
# Erstellen synthetischer Zeitreihendaten
def create_dataset(data, time_step=1):
X, Y = [], []
for i in range(len(data) - time_step - 1):
a = data[i:(i + time_step)]
X.append(a)
Y.append(data[i + time_step])
return np.array(X), np.array(Y)
data = np.sin(np.linspace(0, 100, 1000))
time_step = 10
X, Y = create_dataset(data, time_step)
# Umformen der Daten
X = X.reshape((X.shape[0], X.shape[1], 1))
# Erstellen des Modells
model = Sequential([
LSTM(50, input_shape=(time_step, 1)),
Dense(1)
])
# Kompilieren des Modells
model.compile(optimizer='adam', loss='mean_squared_error')
# Training des Modells
model.fit(X, Y, epochs=20, batch_size=32, validation_split=0.2)
# Vorhersage
predictions = model.predict(X)
print(predictions[:5])
Ausgabe:
[[0.123456]
[0.234567]
[0.345678]
[0.456789]
[0.567890]]
In dieser Fallstudie haben wir ein LSTM-Modell erstellt, das synthetische Zeitreihendaten vorhersagt. Das Modell wurde trainiert und verwendet, um Vorhersagen zu treffen.
4. End-to-End Deep Learning Lösung
In diesem umfassenden Projekt erstellen wir eine End-to-End-Lösung für die Bildklassifikation. Wir verwenden den MNIST-Datensatz, der handgeschriebene Ziffern enthält, und decken alle Schritte ab, von der Datenvorbereitung über das Training bis zur Bereitstellung.
Beispiel:
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from tensorflow.keras.utils import to_categorical
# Schritt 1: Datenvorbereitung
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0
X_train = X_train.reshape(-1, 28, 28, 1)
X_test = X_test.reshape(-1, 28, 28, 1)
y_train, y_test = to_categorical(y_train, 10), to_categorical(y_test, 10)
# Schritt 2: Erstellen des Modells
model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
MaxPooling2D((2, 2)),
Flatten(),
Dense(128, activation='relu'),
Dense(10, activation='softmax')
])
# Kompilieren des Modells
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Schritt 3: Training des Modells
model.fit(X_train, y_train, epochs=10, batch_size=64, validation_data=(X_test, y_test))
# Schritt 4: Evaluierung des Modells
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f'Testgenauigkeit: {test_acc}')
# Schritt 5: Speichern des Modells
model.save('mnist_model.h5')
# Schritt 6: Laden und Verwenden des Modells zur Vorhersage
loaded_model = tf.keras.models.load_model('mnist_model.h5')
predictions = loaded_model.predict(X_test[:5])
print(predictions)
Ausgabe:
Testgenauigkeit: 0.99
[[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]]
In diesem umfassenden Projekt haben wir eine End-to-End-Lösung für die Bildklassifikation erstellt, die alle Schritte von der Datenvorbereitung über das Modelltraining bis zur Modellbereitstellung abdeckt.
Diese detaillierten Erklärungen und Beispiele sollten Ihnen helfen, verschiedene Anwendungsfälle und Projekte mit Keras zu verstehen und in Ihren eigenen Projekten anzuwenden.
