R Academy · Lección

Configuración de Keras y TensorFlow en R

Instale el paquete keras de R, configure un backend de Python y verifique la instalación.

Lección 1 de 413 pasos

Configuración de Keras y TensorFlow en R es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

Aprendizaje profundo en R con Keras

El paquete keras para R proporciona una interfaz de alto nivel para TensorFlow. Posit (anteriormente RStudio) se encarga de su mantenimiento y su API es muy similar a la de Keras para Python. keras para R utiliza reticulate para llamar internamente a TensorFlow de Python, por lo que obtiene toda la potencia de TensorFlow con la sintaxis 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() y backends

install_keras() crea un entorno de Python dedicado (Miniconda o virtualenv) e instala TensorFlow y sus dependencias. Puede especificar la versión de TensorFlow, la versión de Python y si desea instalar compatibilidad con CPU o GPU. De forma predeterminada, instala la versión estable más reciente para CPU.

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

library(keras) carga los enlaces de R. Después de cargarlo, compruebe si el backend de Python de Keras/TF está realmente disponible mediante is_keras_available(). Esta función devuelve TRUE si TensorFlow está instalado y se puede importar, o FALSE con un mensaje útil si falta el entorno de Python.

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

Paquete tensorflow

El paquete tensorflow para R proporciona acceso directo a la API de TensorFlow para Python mediante reticulate. install_tensorflow() funciona de forma similar a install_keras(), pero instala únicamente TensorFlow, sin los componentes adicionales de Keras. Utilícelo cuando necesite operaciones de TF de bajo nivel.

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() — Identificar el backend

k_backend() devuelve una cadena que identifica el backend que utiliza Keras. Keras R moderno (keras3) siempre utiliza TensorFlow. En keras antiguo (v2), también podía utilizar Theano o CNTK. Conocer el backend resulta útil al depurar problemas del entorno.

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'

Comprobar la disponibilidad de la GPU

El entrenamiento en una GPU puede ser entre 10 y 50 veces más rápido que en una CPU para redes grandes. Compruebe la disponibilidad de la GPU y enumere los dispositivos detectados mediante la API de dispositivos de TensorFlow. Si dispone de una GPU NVIDIA y CUDA está instalado, TensorFlow la utilizará automáticamente.

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

Administrar el entorno de Python

Internamente, keras para R utiliza el paquete reticulate para llamar a Python. Utilice reticulate::use_condaenv() o reticulate::use_virtualenv() para seleccionar el entorno de Python que tiene TensorFlow instalado. Debe ejecutar esta función antes de cargar 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__)

Diferencias entre las API de keras3 y keras2

El paquete keras para R se reescribió por completo con la versión 3 (keras3), publicada en 2024. La nueva API utiliza keras_model_sequential() en lugar de keras_model_sequential() |>, así como el estilo basado en pipes para añadir capas. El código antiguo utiliza %>%; el código moderno utiliza el pipe nativo 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)

Verificar una configuración completa

Antes de crear cualquier modelo, ejecute una verificación rápida de extremo a extremo: cree un modelo pequeño, compílelo y entrénelo con datos sintéticos. Si se ejecuta sin errores, la configuración de Keras + TF funciona correctamente.

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

Administración de sesiones y memoria

TensorFlow utiliza intensivamente la GPU y la RAM. En sesiones interactivas de R, llame a keras::backend()$clear_session() para liberar memoria al cambiar de experimento. Para garantizar la reproducibilidad, establezca las semillas aleatorias de TF y R antes de crear los modelos.

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

Descripción general del flujo de trabajo

Un flujo de trabajo habitual de aprendizaje profundo en R sigue estos pasos:

Instalar: install_keras() una vez por máquina
Cargar: library(keras)
Preparar los datos: normalizar las características y convertirlas en matrices
Crear el modelo: keras_model_sequential() + capas
Compilar: especificar la pérdida, el optimizador y las métricas
Ajustar: fit(model, x, y, epochs, callbacks)
Evaluar/Predecir: 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)

Comprobación rápida

¿Qué hace llamar a install_keras() en R?

Responde en la lección interactiva

Resumen de la configuración de Keras

Ideas clave sobre la configuración de Keras y TensorFlow en R:

install_keras() crea un entorno de Python e instala TensorFlow; ejecútelo una vez por máquina.
is_keras_available() comprueba si el backend está disponible antes del entrenamiento.
k_backend() identifica el backend (en keras moderno, siempre TensorFlow).
La disponibilidad de la GPU se comprueba mediante tf$config$list_physical_devices('GPU').
Utilice reticulate::use_condaenv() para seleccionar el entorno de Python adecuado.
Establezca las semillas con set.seed() y tensorflow::set_random_seed() para garantizar la reproducibilidad.
Llame a backend()$clear_session() entre experimentos para liberar memoria.

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

Gratis para empezar

Aprende R con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 43
Lecciones: 159

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Configuración de Keras y TensorFlow en R» es gratis?

Sí — el texto completo de «Configuración de Keras y TensorFlow en R» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Configuración de Keras y TensorFlow en R»?

Instale el paquete keras de R, configure un backend de Python y verifique la instalación. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Configuración de Keras y TensorFlow en R»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Configuración de Keras y TensorFlow en R
Construcción de modelos secuenciales
Fundamentos de las redes neuronales convolucionales
Entrenamiento, validación y prevención del sobreajuste

← Volver a R Academy