1. Laden von Daten mit Keras-Datasets
from keras.datasets import mnist
# Laden des MNIST-Datensatzes
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# Ausgabe der Form der geladenen Daten
print("Trainingsdaten:", X_train.shape, y_train.shape)
print("Testdaten:", X_test.shape, y_test.shape)
Ausgabe:
Trainingsdaten: (60000, 28, 28) (60000,)
Testdaten: (10000, 28, 28) (10000,)
In diesem Beispiel wird der MNIST-Datensatz, der handgeschriebene Ziffern enthält, geladen. Die Daten werden in Trainings- und Testdatensätze aufgeteilt.
2. Datenvorverarbeitung und -augmentation
Datenvorverarbeitung ist ein wichtiger Schritt, um die Daten in ein geeignetes Format für das Training von Modellen zu bringen. Dazu gehören Schritte wie Normalisierung, One-Hot-Encoding und Datenaugmentation.
Beispiel:
from keras.datasets import mnist
from keras.utils import np_utils
from keras.preprocessing.image import ImageDataGenerator
# Laden des MNIST-Datensatzes
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# Vorverarbeitung der Daten
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1).astype('float32') / 255
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1).astype('float32') / 255
# One-Hot-Encoding der Labels
y_train = np_utils.to_categorical(y_train, 10)
y_test = np_utils.to_categorical(y_test, 10)
# Datenaugmentation
datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1
)
datagen.fit(X_train)
In diesem Beispiel wird der MNIST-Datensatz normalisiert, um die Pixelwerte auf den Bereich [0, 1] zu skalieren, und die Labels werden one-hot-encodiert. Dann wird eine Datenaugmentation durchgeführt, um die Trainingsdaten zu erweitern und die Generalisierung des Modells zu verbessern.
3. Verwendung von Generatoren für große Datensätze
Bei großen Datensätzen kann es ineffizient sein, alle Daten gleichzeitig im Speicher zu halten. In solchen Fällen können Generatoren verwendet werden, um Daten in Batches zu laden und zu verarbeiten.
Beispiel:
from keras.preprocessing.image import ImageDataGenerator
# Erstellen eines Generators für Trainingsdaten
train_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
'path_to_train_data',
target_size=(150, 150),
batch_size=32,
class_mode='binary'
)
# Erstellen eines Generators für Validierungsdaten
validation_datagen = ImageDataGenerator(rescale=1./255)
validation_generator = validation_datagen.flow_from_directory(
'path_to_validation_data',
target_size=(150, 150),
batch_size=32,
class_mode='binary'
)
# Ausgabe der Form der generierten Daten
print(next(train_generator)[0].shape)
print(next(validation_generator)[0].shape)
Ausgabe:
Found 2000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.
(32, 150, 150, 3)
(32, 150, 150, 3)
In diesem Beispiel werden Generatoren verwendet, um Bilder aus Verzeichnissen zu laden und in Batches zu verarbeiten. Dies ist besonders nützlich für große Datensätze, die nicht vollständig in den Arbeitsspeicher geladen werden können.
4. Umgang mit unausgeglichenen Datensätzen
Unausgeglichene Datensätze, bei denen eine Klasse viel häufiger als andere vorkommt, können zu schlechten Modellergebnissen führen. Es gibt verschiedene Techniken, um mit unausgeglichenen Datensätzen umzugehen, wie z.B. Über- und Unterabtastung oder die Verwendung von gewichteten Verlustfunktionen.
Beispiel:
from sklearn.utils import class_weight
import numpy as np
# Angenommene Klassenlabels
y_train = np.array([0, 1, 0, 1, 0, 1, 1, 1, 1, 1])
# Berechnung der Klassen-Gewichte
class_weights = class_weight.compute_class_weight('balanced', np.unique(y_train), y_train)
# Ausgabe der berechneten Klassen-Gewichte
print("Klassen-Gewichte:", class_weights)
Ausgabe:
Klassen-Gewichte: [1.66666667 0.625 ]
In diesem Beispiel wird class_weight von sklearn verwendet, um Klassen-Gewichte basierend auf der Häufigkeit der Klassen zu berechnen. Diese Gewichte können dann beim Kompilieren des Modells verwendet werden, um den Einfluss der häufigeren Klasse zu reduzieren.
Anwendung der Klassen-Gewichte im Modelltraining:
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Training des Modells mit Klassen-Gewichten
model.fit(X_train, y_train, epochs=10, batch_size=32, class_weight=class_weights)
Durch diese Techniken zur Datenvorbereitung können Sie sicherstellen, dass Ihre Modelle auf gut vorbereiteten und ausgeglichenen Datensätzen trainiert werden, was zu besseren und robusteren Ergebnissen führt.
