R Academy · Lektion

Keras und TensorFlow in R einrichten

Installieren Sie das R-Paket keras, konfigurieren Sie ein Python-Backend und überprüfen Sie die Einrichtung

Lektion 1 von 413 Schritte

Keras und TensorFlow in R einrichten ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Deep Learning in R mit Keras

Das keras-Paket für R bietet eine High-Level-Schnittstelle zu TensorFlow. Es wird von Posit (früher RStudio) gepflegt und bildet die Python-Keras-API eng nach. R keras verwendet reticulate, um im Hintergrund Python-TensorFlow aufzurufen. Dadurch steht Ihnen die gesamte Leistungsfähigkeit von TensorFlow mit der Syntax von R zur Verfügung.

# Install the R package from CRAN
# install.packages('keras')

# Then install TensorFlow Python environment
library(keras)
install_keras()  # creates a Python venv with TF installed

# For GPU-enabled TensorFlow:
# install_keras(tensorflow = 'gpu')

install_keras() und Backends

install_keras() erstellt eine eigene Python-Umgebung (Miniconda oder virtualenv) und installiert TensorFlow sowie dessen Abhängigkeiten. Sie können die TensorFlow-Version, die Python-Version und die Installation für CPU- oder GPU-Unterstützung festlegen. Standardmäßig wird die aktuelle stabile CPU-Version installiert.

library(keras)

# Install specific TF version in a custom env
install_keras(
  method      = 'conda',
  envname     = 'r-keras-tf2',
  tensorflow  = '2.15',
  version     = 'default'
)

# Check which Python environment is active
reticulate::py_config()

library(keras) und is_keras_available()

library(keras) lädt die R-Anbindungen. Prüfen Sie nach dem Laden mit is_keras_available(), ob das Python-Backend von Keras/TF tatsächlich erreichbar ist. Die Funktion gibt TRUE zurück, wenn TensorFlow installiert und importierbar ist, oder FALSE mit einer hilfreichen Meldung, wenn die Python-Umgebung fehlt.

library(keras)

# Check backend availability
if (is_keras_available()) {
  cat('Keras is ready!\n')
} else {
  cat('Keras not available. Run install_keras() first.\n')
}

# Check TensorFlow Python availability
library(tensorflow)
tf$constant('Hello TensorFlow')

Paket tensorflow

Das R-Paket tensorflow bietet über reticulate direkten Zugriff auf die Python-API von TensorFlow. install_tensorflow() funktioniert ähnlich wie install_keras(), installiert jedoch nur TensorFlow ohne die zusätzlichen Keras-Komponenten. Verwenden Sie es, wenn Sie Operationen auf niedriger Ebene mit TF benötigen.

library(tensorflow)

# Install TF separately if needed
# tensorflow::install_tensorflow()

# Check TF version
tf_version()

# Low-level tensor operation
a <- tf$constant(c(1.0, 2.0, 3.0))
b <- tf$constant(c(4.0, 5.0, 6.0))
c_val <- tf$add(a, b)
print(c_val)

k_backend() — Backend bestimmen

k_backend() gibt eine Zeichenkette zurück, die angibt, welches Backend Keras verwendet. Modernes Keras für R (keras3) verwendet immer TensorFlow. Im älteren keras (v2) konnten auch Theano oder CNTK verwendet werden. Die Kenntnis des Backends ist beim Beheben von Problemen mit der Umgebung hilfreich.

library(keras)

# Check which backend is active
k_backend()  # should return 'tensorflow'

# Check TF version via keras
tf_version()

# Number of tensor dimensions backend uses internally
k_image_data_format()  # 'channels_last' or 'channels_first'

GPU-Verfügbarkeit prüfen

Das Training auf einer GPU kann bei großen Netzwerken 10- bis 50-mal schneller sein als auf einer CPU. Prüfen Sie die GPU-Verfügbarkeit und listen Sie die erkannten Geräte mithilfe der Geräte-API von TensorFlow auf. Wenn eine NVIDIA-GPU und CUDA installiert sind, verwendet TensorFlow die GPU automatisch.

library(tensorflow)

# List all available devices
devices <- tf$config$list_physical_devices()
print(devices)

# Check specifically for GPUs
gpus <- tf$config$list_physical_devices('GPU')
if (length(gpus) > 0) {
  cat('GPU available:', gpus[[1]]$name, '\n')
} else {
  cat('No GPU found — using CPU\n')
}

Python-Umgebung verwalten

R keras verwendet im Hintergrund das Paket reticulate, um Python aufzurufen. Verwenden Sie reticulate::use_condaenv() oder reticulate::use_virtualenv(), um die Python-Umgebung mit der TensorFlow-Installation auszuwählen. Dies muss vor dem Laden von keras erfolgen.

# Select the conda environment before loading keras
library(reticulate)
use_condaenv('r-keras-tf2', required = TRUE)

library(keras)

# Confirm Python path
py_config()$python

# Confirm TF is importable
pytf <- import('tensorflow', convert = FALSE)
cat('TF Version:', pytf$__version__)

API-Unterschiede zwischen keras3 und keras2

Das R-Paket keras wurde mit Version 3 (keras3), die 2024 veröffentlicht wurde, grundlegend überarbeitet. Die neue API verwendet keras_model_sequential() anstelle von keras_model_sequential() |> sowie den Pipe-basierten Stil zum Hinzufügen von Layern. Älterer Code verwendet %>%, moderner Code die native R-Pipe |>.

library(keras3)  # or library(keras) for keras2

# Modern keras3 API with native pipe
model <- keras_model_sequential(input_shape = c(784)) |>
  layer_dense(units = 128, activation = 'relu') |>
  layer_dense(units = 10, activation = 'softmax')

summary(model)

Eine vollständige Einrichtung überprüfen

Führen Sie vor dem Erstellen eines Modells eine kurze End-to-End-Überprüfung durch: Erstellen Sie ein kleines Modell, kompilieren Sie es und trainieren Sie es mit synthetischen Daten. Wenn dies fehlerfrei ausgeführt wird, funktioniert Ihre Einrichtung mit Keras und TF ordnungsgemäß.

library(keras)

# Quick smoke test
model <- keras_model_sequential(input_shape = c(10)) |>
  layer_dense(units = 32, activation = 'relu') |>
  layer_dense(units = 1,  activation = 'linear')

model |> compile(
  optimizer = 'adam',
  loss      = 'mse'
)

# Train on random data
x_rand <- matrix(rnorm(1000 * 10), ncol = 10)
y_rand <- rnorm(1000)

model |> fit(x_rand, y_rand, epochs = 3, batch_size = 32, verbose = 0)
cat('Setup OK!')

Sitzungs- und Speicherverwaltung

TensorFlow nutzt GPU und RAM intensiv. Rufen Sie in interaktiven R-Sitzungen keras::backend()$clear_session() auf, um beim Wechsel zwischen Experimenten Speicher freizugeben. Setzen Sie für reproduzierbare Ergebnisse die Zufallsstartwerte von TF und R, bevor Sie Modelle erstellen.

library(keras)

# Set seeds for reproducibility
set.seed(42)
tensorflow::set_random_seed(42)

# Clear any previous session state
keras::backend()$clear_session()

# Limit GPU memory growth (prevents OOM errors)
gpus <- tensorflow::tf$config$list_physical_devices('GPU')
if (length(gpus) > 0) {
  tensorflow::tf$config$experimental$set_memory_growth(
    gpus[[1]], TRUE
  )
}

Überblick über den Arbeitsablauf

Ein typischer Deep-Learning-Arbeitsablauf in R umfasst die folgenden Schritte:

Installieren: install_keras() einmal pro Computer
Laden: library(keras)
Daten vorbereiten: Merkmale normalisieren, in Matrizen umwandeln
Modell erstellen: keras_model_sequential() + Layer
Kompilieren: Verlustfunktion, Optimierer und Metriken festlegen
Trainieren: fit(model, x, y, epochs, callbacks)
Evaluieren/Vorhersagen: evaluate() + predict()

# Step-by-step outline (each step covered in next lessons)
library(keras)

# 1. Data ready as matrices (normalised)
# x_train, y_train, x_test, y_test

# 2. Model
model <- keras_model_sequential(input_shape = ncol(x_train)) |>
  layer_dense(128, activation = 'relu') |>
  layer_dense(1,   activation = 'sigmoid')

# 3. Compile
model |> compile('adam', 'binary_crossentropy', metrics = 'accuracy')

# 4. Fit
model |> fit(x_train, y_train, epochs = 20)

# 5. Evaluate
model |> evaluate(x_test, y_test)

Kurze Überprüfung

Was bewirkt der Aufruf von install_keras() in R?

Beantworte es in der interaktiven Lektion

Zusammenfassung der Keras-Einrichtung

Die wichtigsten Erkenntnisse zur Einrichtung von Keras und TensorFlow in R:

install_keras() erstellt eine Python-Umgebung und installiert TensorFlow – führen Sie die Funktion einmal pro Computer aus.
is_keras_available() prüft vor dem Training, ob das Backend erreichbar ist.
k_backend() bestimmt das Backend (bei modernem keras immer TensorFlow).
Die GPU-Verfügbarkeit wird über tf$config$list_physical_devices('GPU') geprüft.
Verwenden Sie reticulate::use_condaenv(), um die richtige Python-Umgebung auszuwählen.
Setzen Sie mit set.seed() und tensorflow::set_random_seed() Startwerte für reproduzierbare Ergebnisse.
Rufen Sie zwischen Experimenten backend()$clear_session() auf, um Speicher freizugeben.

# Minimal verified setup check
library(keras)

if (!is_keras_available()) {
  install_keras()
}

cat('Backend:', k_backend(), '\n')
cat('TF Version:', tf_version(), '\n')
cat('Image format:', k_image_data_format(), '\n')

Kostenlos starten

Lerne R mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 43
Lektionen: 159

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Keras und TensorFlow in R einrichten“ kostenlos?

Ja — der vollständige Text von „Keras und TensorFlow in R einrichten“ 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 „Keras und TensorFlow in R einrichten“?

Installieren Sie das R-Paket keras, konfigurieren Sie ein Python-Backend und überprüfen Sie die Einrichtung 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 1 von 4.

Wie lange dauert die Lektion „Keras und TensorFlow in R einrichten“?

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

← Zurück zu R Academy