R Academy · Aula

Configurando Keras e TensorFlow no R

Instale o pacote keras para R, configure um back-end Python e verifique a configuração.

Aula 1 de 413 etapas

Configurando Keras e TensorFlow no R é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Aprendizado profundo em R com Keras

O pacote keras para R fornece uma interface de alto nível para o TensorFlow. Ele é mantido pela Posit (anteriormente RStudio) e reproduz de perto a API Keras do Python. O keras para R usa o reticulate para chamar o TensorFlow do Python internamente; assim, você obtém todo o poder do TensorFlow com a sintaxe do 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() e backends

install_keras() cria um ambiente Python dedicado (Miniconda ou virtualenv) e instala o TensorFlow e suas dependências. Você pode especificar a versão do TensorFlow, a versão do Python e se deseja instalar suporte para CPU ou GPU. Por padrão, ele instala a versão estável mais recente 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) carrega as vinculações do R. Depois de carregá-las, verifique se o backend Python do Keras/TF está realmente acessível usando is_keras_available(). Essa função retorna TRUE se o TensorFlow estiver instalado e puder ser importado, ou FALSE com uma mensagem útil se o ambiente Python estiver ausente.

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

Pacote tensorflow

O pacote tensorflow para R fornece acesso direto à API Python do TensorFlow por meio do reticulate. install_tensorflow() funciona de modo semelhante a install_keras(), mas instala somente o TensorFlow, sem os recursos adicionais do Keras. Utilize-o quando precisar de operações de baixo nível do TF.

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 o backend

k_backend() retorna uma cadeia de caracteres que identifica qual backend o Keras está utilizando. O Keras R moderno (keras3) sempre utiliza o TensorFlow. No keras antigo (v2), também era possível utilizar Theano ou CNTK. Saber qual é o backend é útil ao investigar problemas no ambiente.

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'

Verificando a disponibilidade da GPU

O treinamento em uma GPU pode ser de 10 a 50 vezes mais rápido que em uma CPU para redes grandes. Verifique a disponibilidade da GPU e liste os dispositivos detectados usando a API de dispositivos do TensorFlow. Se você tiver uma GPU NVIDIA e o CUDA instalado, o TensorFlow a utilizará automaticamente.

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

Gerenciando o ambiente Python

Internamente, o keras para R utiliza o pacote reticulate para chamar o Python. Use reticulate::use_condaenv() ou reticulate::use_virtualenv() para selecionar o ambiente Python que tem o TensorFlow instalado. Isso deve ser chamado antes de carregar o 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__)

Diferenças entre as APIs keras3 e keras2

O pacote keras para R passou por uma grande reformulação na versão 3 (keras3), lançada em 2024. A nova API utiliza keras_model_sequential() em vez de keras_model_sequential() |> e o estilo de adição de camadas baseado em pipes. O código antigo usa %>%; o código moderno usa o pipe nativo do 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)

Verificando uma configuração completa

Antes de criar qualquer modelo, faça uma verificação rápida de ponta a ponta: crie um modelo pequeno, compile-o e treine-o com dados sintéticos. Se isso for executado sem erros, sua configuração do Keras + TF estará funcionando corretamente.

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

Gerenciamento de sessões e memória

O TensorFlow utiliza GPU e RAM intensivamente. Em sessões interativas do R, chame keras::backend()$clear_session() para liberar memória ao alternar entre experimentos. Para garantir a reprodutibilidade, defina as sementes aleatórias do TF e do R antes de criar os 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
  )
}

Visão geral do fluxo de trabalho

Um fluxo de trabalho típico de aprendizado profundo em R segue estas etapas:

Instalar: install_keras() uma vez por máquina
Carregar: library(keras)
Preparar os dados: normalize as características e converta-as em matrizes
Criar o modelo: keras_model_sequential() + camadas
Compilar: especifique a perda, o otimizador e as métricas
Ajustar: fit(model, x, y, epochs, callbacks)
Avaliar/Prever: 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)

Verificação rápida

O que a chamada de install_keras() em R faz?

Responda na aula interativa

Recapitulação da configuração do Keras

Principais conclusões sobre a configuração do Keras e do TensorFlow em R:

install_keras() cria um ambiente Python e instala o TensorFlow — execute uma vez por máquina.
is_keras_available() verifica se o backend está acessível antes do treinamento.
k_backend() identifica o backend (sempre TensorFlow no keras moderno).
A disponibilidade da GPU é verificada por meio de tf$config$list_physical_devices('GPU').
Use reticulate::use_condaenv() para selecionar o ambiente Python correto.
Defina as sementes com set.seed() e tensorflow::set_random_seed() para garantir a reprodutibilidade.
Chame backend()$clear_session() entre os experimentos para liberar memória.

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

Grátis para começar

Aprenda R com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 43
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Configurando Keras e TensorFlow no R” é grátis?

Sim — o texto completo de “Configurando Keras e TensorFlow no R” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Configurando Keras e TensorFlow no R”?

Instale o pacote keras para R, configure um back-end Python e verifique a configuração. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Configurando Keras e TensorFlow no R”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Configurando Keras e TensorFlow no R
Construindo modelos sequenciais
Fundamentos das redes neurais convolucionais
Treinamento, validação e prevenção do sobreajuste

← Voltar para R Academy