R Academy · Lezione

Configurazione di Keras e TensorFlow in R

Installi il pacchetto R keras, configuri un backend Python e verifichi la configurazione

Lezione 1 di 413 passaggi

Configurazione di Keras e TensorFlow in R è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Deep learning in R con Keras

Il package R keras fornisce un’interfaccia di alto livello per TensorFlow. È gestito da Posit (in precedenza RStudio) e rispecchia da vicino l’API Keras di Python. keras per R utilizza reticulate per chiamare TensorFlow in Python, offrendo tutta la potenza di TensorFlow con la sintassi di 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 backend

install_keras() crea un ambiente Python dedicato (Miniconda o virtualenv) e installa TensorFlow con le relative dipendenze. È possibile specificare la versione di TensorFlow, la versione di Python e se installare il supporto per CPU o GPU. Per impostazione predefinita installa l’ultima versione stabile per 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) carica i binding R. Dopo il caricamento, verifichi se il backend Python di Keras/TF è effettivamente raggiungibile con is_keras_available(). Questa funzione restituisce TRUE se TensorFlow è installato e può essere importato, oppure FALSE con un messaggio utile se manca l’ambiente 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')

Package tensorflow

Il package R tensorflow fornisce accesso diretto all’API Python di TensorFlow tramite reticulate. install_tensorflow() funziona in modo analogo a install_keras(), ma installa solo TensorFlow, senza gli extra di Keras. Lo utilizzi quando sono necessarie operazioni TF di basso livello.

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() — Identificare il backend

k_backend() restituisce una stringa che identifica il backend utilizzato da Keras. Keras R moderno (keras3) utilizza sempre TensorFlow. Nelle versioni precedenti di keras (v2) poteva utilizzare anche Theano o CNTK. Conoscere il backend è utile per eseguire il debug dei problemi dell’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'

Verifica della disponibilità della GPU

L’addestramento su una GPU può essere da 10 a 50 volte più veloce rispetto alla CPU per le reti di grandi dimensioni. Verifichi la disponibilità della GPU e elenchi i dispositivi rilevati utilizzando l’API dei dispositivi di TensorFlow. Se dispone di una GPU NVIDIA e CUDA è installato, TensorFlow la utilizzerà 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')
}

Gestione dell’ambiente Python

Internamente, keras per R utilizza il package reticulate per chiamare Python. Utilizzi reticulate::use_condaenv() o reticulate::use_virtualenv() per selezionare l’ambiente Python in cui è installato TensorFlow. Questa operazione deve essere eseguita prima di caricare 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__)

Differenze tra le API di keras3 e keras2

Il package R keras è stato completamente riscritto con la versione 3 (keras3), rilasciata nel 2024. La nuova API utilizza keras_model_sequential() invece di keras_model_sequential() |> e lo stile basato sulla pipe per aggiungere i layer. Il codice precedente utilizza %>%; quello moderno utilizza la pipe nativa di 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)

Verifica di una configurazione completa

Prima di creare un modello, esegua una rapida verifica completa: crei un modello minimo, lo compili e lo addestri su dati sintetici. Se l’operazione viene completata senza errori, la configurazione Keras + TF funziona correttamente.

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

Gestione delle sessioni e della memoria

TensorFlow utilizza intensivamente la GPU e la RAM. Nelle sessioni interattive di R, chiami keras::backend()$clear_session() per liberare memoria quando passa da un esperimento all’altro. Per garantire la riproducibilità, imposti i seed casuali di TF e R prima di creare i modelli.

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

Panoramica del flusso di lavoro

Un tipico flusso di lavoro di deep learning in R prevede questi passaggi:

Installazione: install_keras() una volta per macchina
Caricamento: library(keras)
Preparazione dei dati: normalizzare le caratteristiche, convertirle in matrici
Creazione del modello: keras_model_sequential() + layer
Compilazione: specificare loss, optimizer e metriche
Addestramento: fit(model, x, y, epochs, callbacks)
Valutazione/Previsione: 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 rapida

Che cosa fa la chiamata a install_keras() in R?

Rispondi nella lezione interattiva

Riepilogo della configurazione di Keras

Punti chiave su Configurazione di Keras e TensorFlow in R:

install_keras() crea un ambiente Python e installa TensorFlow — eseguirlo una volta per macchina.
is_keras_available() verifica che il backend sia raggiungibile prima dell’addestramento.
k_backend() identifica il backend (nelle versioni moderne di keras è sempre TensorFlow).
La disponibilità della GPU viene verificata tramite tf$config$list_physical_devices('GPU').
Utilizzi reticulate::use_condaenv() per selezionare l’ambiente Python corretto.
Imposti i seed con set.seed() e tensorflow::set_random_seed() per garantire la riproducibilità.
Chiami backend()$clear_session() tra un esperimento e l’altro per liberare 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 per iniziare

Impara R con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 43
Lezioni: 159

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Configurazione di Keras e TensorFlow in R» è gratuita?

Sì — il testo completo di «Configurazione di Keras e TensorFlow in R» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Configurazione di Keras e TensorFlow in R»?

Installi il pacchetto R keras, configuri un backend Python e verifichi la configurazione Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Configurazione di Keras e TensorFlow in R»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Configurazione di Keras e TensorFlow in R
Costruzione di modelli sequenziali
Fondamenti delle reti neurali convoluzionali
Addestramento, validazione e prevenzione dell'overfitting

← Torna a R Academy