Sequenzielle Modelle erstellen
Stapeln Sie Dense-Schichten, wenden Sie Aktivierungsfunktionen an und kompilieren Sie das Modell mit Loss und Optimizer
Sequenzielle Modelle erstellen ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Das Sequential-Modell
Ein Sequential-Modell ist eine lineare Abfolge von Layern, bei der jeder Layer genau einen Eingabetensor und einen Ausgabetensor besitzt. Es ist der einfachste Keras-Modelltyp und deckt die meisten praktischen Anwendungsfälle ab: Feedforward-Klassifikatoren, Regressoren sowie einfache CNNs und RNNs.
library(keras)
# An empty sequential model
model <- keras_model_sequential()
print(model)
# Or specify the input shape upfront
model <- keras_model_sequential(input_shape = c(20))
print(model)layer_dense() — Vollständig verbundener Layer
layer_dense(units, activation) fügt einen vollständig verbundenen (dichten) Layer hinzu, bei dem jedes Eingabeneuron mit jedem Ausgabeneuron verbunden ist. Das Argument units legt die Dimension der Ausgabe fest. activation wendet eine Nichtlinearität an: 'relu' ist für Hidden Layer üblich.
library(keras)
model <- keras_model_sequential(input_shape = c(30)) |>
layer_dense(units = 128, activation = 'relu') |>
layer_dense(units = 64, activation = 'relu') |>
layer_dense(units = 1, activation = 'sigmoid')
# Print architecture
summary(model)Aktivierungsfunktionen der Ausgabeschicht
Die Aktivierungsfunktion des letzten Layers hängt von der Aufgabe ab:
'sigmoid': binäre Klassifikation (gibt eine Wahrscheinlichkeit zwischen 0 und 1 aus)'softmax': Mehrklassenklassifikation (gibt Wahrscheinlichkeiten aus, deren Summe 1 ergibt)'linear'oder keine Aktivierungsfunktion: Regression (gibt reelle Vorhersagewerte aus)
# Binary classification
binary_model <- keras_model_sequential(input_shape = c(20)) |>
layer_dense(64, activation = 'relu') |>
layer_dense(1, activation = 'sigmoid') # P(class=1)
# Multi-class (10 classes)
multi_model <- keras_model_sequential(input_shape = c(20)) |>
layer_dense(64, activation = 'relu') |>
layer_dense(10, activation = 'softmax') # P per class
# Regression
reg_model <- keras_model_sequential(input_shape = c(20)) |>
layer_dense(64, activation = 'relu') |>
layer_dense(1, activation = 'linear') # raw valuecompile() — Verlustfunktion, Optimierer, Metriken
compile(loss, optimizer, metrics) konfiguriert den Lernprozess. Typische Kombinationen:
- Binär:
loss = 'binary_crossentropy',metrics = 'accuracy' - Mehrklassen:
loss = 'categorical_crossentropy' - Regression:
loss = 'mse',metrics = 'mae'
model |> compile(
loss = 'binary_crossentropy',
optimizer = optimizer_adam(learning_rate = 0.001),
metrics = c('accuracy')
)
# Check configuration
model$loss
model$optimizer$get_config()optimizer_adam()
Adam (Adaptive Moment Estimation) ist der Standardoptimierer für die meisten Deep-Learning-Aufgaben. Er passt die Lernrate für jeden Parameter anhand von Schätzungen des ersten und zweiten Moments der Gradienten an. Die standardmäßige Lernrate von 0.001 ist für die meisten Probleme ein guter Ausgangspunkt.
# Adam with default settings
model |> compile(
optimizer = 'adam',
loss = 'binary_crossentropy',
metrics = 'accuracy'
)
# Customised Adam
model |> compile(
optimizer = optimizer_adam(
learning_rate = 0.0005,
beta_1 = 0.9,
beta_2 = 0.999,
epsilon = 1e-7
),
loss = 'binary_crossentropy',
metrics = 'accuracy'
)fit() — Das Modell trainieren
fit(model, x, y, epochs, batch_size, validation_split) trainiert das Modell. Jede Epoche ist ein vollständiger Durchlauf durch die Trainingsdaten. Die Batch-Größe legt fest, wie viele Stichproben vor jeder Aktualisierung der Gewichte verarbeitet werden. Die Funktion gibt ein History-Objekt zurück.
# Prepare example data
x_train <- matrix(rnorm(1000 * 20), nrow = 1000)
y_train <- sample(c(0, 1), 1000, replace = TRUE)
history <- model |> fit(
x = x_train,
y = y_train,
epochs = 20,
batch_size = 32,
validation_split = 0.2, # reserve 20% for validation
verbose = 1
)
plot(history)Layer-Regularisierung — Dropout
layer_dropout(rate) setzt während des Trainings zufällig einen Anteil rate der Eingabeeinheiten auf 0. Dadurch wird verhindert, dass sich Neuronen zu stark aneinander anpassen; zugleich wirkt Dropout als leistungsfähige Regularisierung. Dropout ist nur während des Trainings aktiv, nicht bei der Inferenz.
model <- keras_model_sequential(input_shape = c(784)) |>
layer_dense(512, activation = 'relu') |>
layer_dropout(rate = 0.4) |>
layer_dense(256, activation = 'relu') |>
layer_dropout(rate = 0.3) |>
layer_dense(10, activation = 'softmax')
summary(model)L1- und L2-Regularisierung der Gewichte
Regularisieren Sie einzelne Layer mit kernel_regularizer, um große Gewichte zu bestrafen. L2 (Ridge) bestraft die Summe der quadrierten Gewichte; L1 (Lasso) bestraft die Absolutwerte und fördert Sparsität. Beide Varianten sind über regularizer_l2() und regularizer_l1() verfügbar.
model <- keras_model_sequential(input_shape = c(100)) |>
layer_dense(
units = 64,
activation = 'relu',
kernel_regularizer = regularizer_l2(l = 0.01)
) |>
layer_dense(
units = 32,
activation = 'relu',
kernel_regularizer = regularizer_l1_l2(l1 = 1e-4, l2 = 1e-3)
) |>
layer_dense(1, activation = 'sigmoid')
summary(model)Batch-Normalisierung
layer_batch_normalization() normalisiert die Aktivierungen des vorherigen Layers für jeden Mini-Batch. Dies stabilisiert das Training, ermöglicht höhere Lernraten und wirkt als leichte Regularisierung. Platzieren Sie den Layer nach layer_dense() und vor der Aktivierungsfunktion oder nach der Aktivierung – beide Varianten werden in der Praxis verwendet.
model <- keras_model_sequential(input_shape = c(100)) |>
layer_dense(256, use_bias = FALSE) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dense(128, use_bias = FALSE) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dense(1, activation = 'sigmoid')
summary(model)evaluate() und predict()
evaluate(model, x_test, y_test) berechnet den Loss und die Metriken für Testdaten. predict(model, x_new) erzeugt Rohvorhersagen – bei der Klassifikation Wahrscheinlichkeiten. Beide akzeptieren numerische Matrizen und geben konsistente, native R-Werte zurück.
x_test <- matrix(rnorm(200 * 20), nrow = 200)
y_test <- sample(c(0, 1), 200, replace = TRUE)
# Evaluate on test set
test_metrics <- model |> evaluate(x_test, y_test, verbose = 0)
cat('Test Loss:', test_metrics['loss'])
cat('Test Accuracy:', test_metrics['accuracy'])
# Generate predictions
prob_preds <- model |> predict(x_test)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
table(class_preds, y_test)Modelle speichern und laden
Speichern Sie ein kompiliertes und trainiertes Modell mit save_model_tf(model, 'path') (TF-SavedModel-Format, empfohlen) oder save_model_hdf5(model, 'model.h5'). Laden Sie es mit load_model_tf() oder load_model_hdf5() erneut. Das geladene Modell behält die Kompilierungseinstellungen bei und kann sofort Vorhersagen treffen oder weiter trainiert werden.
# Save in TensorFlow SavedModel format (recommended)
save_model_tf(model, '/tmp/my_dense_model')
# Reload
loaded <- load_model_tf('/tmp/my_dense_model')
# Confirm predictions match
new_preds <- loaded |> predict(x_test)
all.equal(prob_preds, new_preds) # TRUEKurze Überprüfung
Welche Aktivierungsfunktion und wie viele Units sollte die Ausgabeschicht bei einem Sequential-Modell für ein Klassifikationsproblem mit 5 Klassen verwenden?
Zusammenfassung zu Sequential-Modellen
Wichtige Erkenntnisse zum Erstellen von Sequential-Modellen:
keras_model_sequential()erstellt eine lineare Schichtenfolge.layer_dense(units, activation)ist die zentrale vollständig verbundene Schicht.- Ausgabeaktivierung:
'sigmoid'(binär),'softmax'(mehrklassig),'linear'(Regression). compile(loss, optimizer, metrics)konfiguriert den Lernprozess.fit(model, x, y, epochs, batch_size, validation_split)trainiert das Modell.- Regularisierung:
layer_dropout(rate),regularizer_l2(),layer_batch_normalization(). - Speichern mit
save_model_tf(), Laden mitload_model_tf().
library(keras)
model <- keras_model_sequential(input_shape = c(30)) |>
layer_dense(128, activation = 'relu') |>
layer_dropout(0.4) |>
layer_dense(64, activation = 'relu') |>
layer_dropout(0.3) |>
layer_dense(1, activation = 'sigmoid')
model |> compile(
optimizer = optimizer_adam(0.001),
loss = 'binary_crossentropy',
metrics = 'accuracy'
)
history <- model |> fit(
x_train, y_train,
epochs = 30, batch_size = 64,
validation_split = 0.2, verbose = 0
)
plot(history)Häufig gestellte Fragen
Ist die Lektion „Sequenzielle Modelle erstellen“ kostenlos?
Ja — der vollständige Text von „Sequenzielle Modelle erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Sequenzielle Modelle erstellen“?
Stapeln Sie Dense-Schichten, wenden Sie Aktivierungsfunktionen an und kompilieren Sie das Modell mit Loss und Optimizer Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um R Academy zu starten?
Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Sequenzielle Modelle erstellen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?
Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Keras und TensorFlow in R einrichten
- Sequenzielle Modelle erstellen
- Grundlagen konvolutionaler neuronaler Netze
- Training, Validierung und Vermeidung von Overfitting