R Academy · Lektion

Opbygning af sekventielle modeller

Sammensæt Dense-lag, anvend activation functions, og kompilér med loss og optimizer.

Lektion 2 af 413 trin

Opbygning af sekventielle modeller er en gratis R Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i R Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. R Academy-kurset indeholder 4 lektioner i alt.

Den sekventielle model

En sekventiel model er en lineær stak af lag, hvor hvert lag har præcis én inputtensor og én outputtensor. Det er den enkleste type Keras-model og dækker størstedelen af praktiske anvendelser: feedforward-klassifikatorer, regressionsmodeller og grundlæggende CNN'er/RNN'er.

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() — Fuldt forbundet lag

layer_dense(units, activation) tilføjer et fuldt forbundet lag, hvor hver inputneuron er forbundet med hver outputneuron. Argumentet units angiver outputdimensionen. activation anvender en ikke-linearitet: 'relu' er standard for skjulte lag.

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)

Aktiveringsfunktioner i outputlaget

Det sidste lags aktiveringsfunktion afhænger af opgaven:

'sigmoid': binær klassifikation (returnerer en sandsynlighed mellem 0 og 1)
'softmax': flerklasseklassifikation (returnerer sandsynligheder, hvis sum er 1)
'linear' eller ingen aktiveringsfunktion: regression (returnerer numeriske forudsigelser)

# 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 value

compile() — Tab, optimeringsmetode og målinger

compile(loss, optimizer, metrics) konfigurerer læringsprocessen. Typiske kombinationer:

Binær: loss = 'binary_crossentropy', metrics = 'accuracy'
Flerklasse: 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) er standardoptimeringsmetoden til de fleste deep learning-opgaver. Den tilpasser læringsraten for hver parameter ved hjælp af estimater af gradienternes første og anden momenter. Standardlæringsraten på 0.001 er et godt udgangspunkt for de fleste problemer.

# 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() — Træning af modellen

fit(model, x, y, epochs, batch_size, validation_split) træner modellen. Hver epoke er én fuld gennemgang af træningsdataene. Batchstørrelsen bestemmer, hvor mange eksempler der behandles før hver vægtopdatering. Funktionen returnerer et historikobjekt.

# 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)

Regularisering af lag — Dropout

layer_dropout(rate) sætter tilfældigt en andel rate af inputenhederne til 0 under træningen. Det forhindrer neuronerne i at tilpasse sig for tæt til hinanden og fungerer som en effektiv regularisering. Dropout er kun aktiv under træningen, ikke under inferens.

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- og L2-regularisering af vægte

Regularisér individuelle lag med kernel_regularizer for at straffe store vægte. L2 (ridge) straffer summen af de kvadrerede vægte, mens L1 (lasso) straffer de absolutte værdier og fremkalder sparsitet. Begge er tilgængelige via regularizer_l2() og regularizer_l1().

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)

Batchnormalisering

layer_batch_normalization() normaliserer aktiveringerne fra det foregående lag for hvert minibatch. Det stabiliserer træningen, gør højere læringsrater mulige og fungerer som en mild regularisering. Placér det efter layer_dense() og før aktiveringsfunktionen eller efter aktiveringen — begge dele bruges i praksis.

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() og predict()

evaluate(model, x_test, y_test) beregner tabsfunktionen og målepunkterne på testdata. predict(model, x_new) genererer rå forudsigelser — sandsynligheder ved klassifikation. Begge accepterer numeriske matricer og returnerer ensartede, R-native værdier.

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)

Lagring og indlæsning af modeller

Gem en kompileret og trænet model med save_model_tf(model, 'path') (TF SavedModel-format, anbefalet) eller save_model_hdf5(model, 'model.h5'). Indlæs den igen med load_model_tf() eller load_model_hdf5(). Den indlæste model bevarer kompileringsindstillingerne og kan straks lave forudsigelser eller fortsætte træningen.

# 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)  # TRUE

Hurtigt tjek

Når du bygger en sekventiel model til et klassifikationsproblem med 5 klasser, hvilken aktiveringsfunktion og hvor mange enheder skal outputlaget bruge?

Besvar den i den interaktive lektion

Opsummering af sekventielle modeller

Vigtige pointer fra opbygning af sekventielle modeller:

keras_model_sequential() opretter en lineær stak af lag.
layer_dense(units, activation) er det grundlæggende fuldt forbundne lag.
Outputaktivering: 'sigmoid' (binær), 'softmax' (flere klasser), 'linear' (regression).
compile(loss, optimizer, metrics) konfigurerer læringsprocessen.
fit(model, x, y, epochs, batch_size, validation_split) træner modellen.
Regularisering: layer_dropout(rate), regularizer_l2(), layer_batch_normalization().
Gem med save_model_tf(), og indlæs med load_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)

Gratis at komme i gang

Lær R med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 43
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Opbygning af sekventielle modeller” gratis?

Ja — alle 3 lektioner i læringssporet R Academy, inklusive “Opbygning af sekventielle modeller”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. R Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Opbygning af sekventielle modeller”?

Sammensæt Dense-lag, anvend activation functions, og kompilér med loss og optimizer. Du øver dig i R Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på R Academy?

Der kræves ingen tidligere erfaring. R Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Opbygning af sekventielle modeller”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne R Academy-lektion?

Ja. Alle R Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Opsætning af Keras og TensorFlow i R
Opbygning af sekventielle modeller
Grundlæggende convolutional neural networks
Træning, validering og forebyggelse af overfitting

← Tilbage til R Academy