R Academy · Leçon

Configurer Keras et TensorFlow dans R

Installez le paquet R keras, configurez un moteur Python et vérifiez la configuration.

Leçon 1 sur 413 étapes

Configurer Keras et TensorFlow dans R est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Apprentissage profond en R avec Keras

Le package R keras fournit une interface de haut niveau vers TensorFlow. Il est maintenu par Posit (anciennement RStudio) et reproduit étroitement l’API Keras de Python. keras pour R utilise reticulate pour appeler TensorFlow en Python en arrière-plan ; vous bénéficiez ainsi de toute la puissance de TensorFlow avec la syntaxe de R.

# 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() et les moteurs d’exécution

install_keras() crée un environnement Python dédié (Miniconda ou virtualenv) et installe TensorFlow ainsi que ses dépendances. Vous pouvez préciser la version de TensorFlow, la version de Python et si la prise en charge du CPU ou du GPU doit être installée. Par défaut, la dernière version stable pour CPU est installée.

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) et is_keras_available()

library(keras) charge les liaisons R. Après le chargement, vérifiez que le moteur Python de Keras/TF est effectivement accessible avec is_keras_available(). Cette fonction renvoie TRUE si TensorFlow est installé et peut être importé, ou FALSE avec un message explicatif si l’environnement Python est absent.

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

Package tensorflow

Le package R tensorflow fournit un accès direct à l’API Python de TensorFlow par l’intermédiaire de reticulate. install_tensorflow() fonctionne comme install_keras(), mais installe uniquement TensorFlow, sans les composants supplémentaires de Keras. Utilisez-le lorsque vous avez besoin d’opérations TF de bas niveau.

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() — Identifier le moteur

k_backend() renvoie une chaîne identifiant le moteur utilisé par Keras. Keras R moderne (keras3) utilise toujours TensorFlow. Dans les anciennes versions de keras (v2), il pouvait également utiliser Theano ou CNTK. Connaître le moteur est utile pour résoudre les problèmes d’environnement.

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'

Vérification de la disponibilité du GPU

L’entraînement sur un GPU peut être 10 à 50 fois plus rapide que sur un CPU pour les grands réseaux. Vérifiez la disponibilité du GPU et répertoriez les appareils détectés à l’aide de l’API des appareils de TensorFlow. Si vous disposez d’un GPU NVIDIA et de CUDA, TensorFlow l’utilisera automatiquement.

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')
}

Gestion de l’environnement Python

En arrière-plan, keras pour R utilise le package reticulate pour appeler Python. Utilisez reticulate::use_condaenv() ou reticulate::use_virtualenv() pour sélectionner l’environnement Python dans lequel TensorFlow est installé. Cette fonction doit être appelée avant le chargement de keras.

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

Différences d’API entre keras3 et keras2

Le package R keras a fait l’objet d’une réécriture majeure avec la version 3 (keras3), publiée en 2024. La nouvelle API utilise keras_model_sequential() au lieu de keras_model_sequential() |>, ainsi qu’un style d’ajout des couches fondé sur l’opérateur pipe. L’ancien code utilise %>% ; le code moderne utilise le pipe natif de R |>.

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)

Vérification complète de la configuration

Avant de créer un modèle, effectuez une vérification rapide de bout en bout : créez un petit modèle, compilez-le et entraînez-le sur des données synthétiques. Si cette opération s’exécute sans erreurs, votre configuration Keras + TF fonctionne correctement.

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!')

Gestion des sessions et de la mémoire

TensorFlow utilise intensivement le GPU et la RAM. Dans les sessions R interactives, appelez keras::backend()$clear_session() pour libérer de la mémoire lorsque vous changez d’expérience. Pour garantir la reproductibilité, définissez les valeurs initiales aléatoires de TF et de R avant de créer les modèles.

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

Vue d’ensemble du flux de travail

Un flux de travail type d’apprentissage profond en R suit les étapes suivantes :

Installer : install_keras() une fois par machine
Charger : library(keras)
Préparer les données : normaliser les variables, les convertir en matrices
Construire le modèle : keras_model_sequential() + couches
Compiler : préciser la perte, l’optimiseur et les métriques
Entraîner : fit(model, x, y, epochs, callbacks)
Évaluer/Prédire : 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)

Vérification rapide

Que fait l’appel à install_keras() dans R ?

Réponds-y dans la leçon interactive

Récapitulatif de la configuration de Keras

Points essentiels à retenir sur la configuration de Keras et TensorFlow dans R :

install_keras() crée un environnement Python et installe TensorFlow — à exécuter une fois par machine.
is_keras_available() vérifie que le moteur est accessible avant l’entraînement.
k_backend() identifie le moteur (toujours TensorFlow dans keras moderne).
La disponibilité du GPU se vérifie avec tf$config$list_physical_devices('GPU').
Utilisez reticulate::use_condaenv() pour sélectionner l’environnement Python approprié.
Définissez les valeurs initiales avec set.seed() et tensorflow::set_random_seed() pour garantir la reproductibilité.
Appelez backend()$clear_session() entre les expériences pour libérer de la mémoire.

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

Gratuit pour commencer

Apprends R avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 43
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Configurer Keras et TensorFlow dans R » est-elle gratuite ?

Oui — le texte complet de « Configurer Keras et TensorFlow dans R » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Configurer Keras et TensorFlow dans R » ?

Installez le paquet R keras, configurez un moteur Python et vérifiez la configuration. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Configurer Keras et TensorFlow dans R » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configurer Keras et TensorFlow dans R
Construire des modèles séquentiels
Bases des réseaux neuronaux convolutifs
Entraînement, validation et prévention du surapprentissage

← Retour à R Academy