R Academy · Lekcja

Konfiguracja Keras i TensorFlow w R

Zainstaluj pakiet R keras, skonfiguruj backend Pythona i sprawdź poprawność konfiguracji.

Konfiguracja Keras i TensorFlow w R to bezpłatna lekcja R Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Uczenie głębokie w R za pomocą Keras

Pakiet R keras udostępnia wysokopoziomowy interfejs do TensorFlow. Jest utrzymywany przez Posit (wcześniej RStudio) i w dużym stopniu odzwierciedla interfejs API Keras dla Pythona. R keras używa pakietu reticulate do wywoływania TensorFlow w Pythonie, dzięki czemu mogą Państwo korzystać z pełnych możliwości TensorFlow, używając składni 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() i backendy

install_keras() tworzy dedykowane środowisko Pythona (Miniconda lub virtualenv) i instaluje TensorFlow wraz z zależnościami. Można określić wersję TensorFlow, wersję Pythona oraz to, czy ma zostać zainstalowana obsługa CPU lub GPU. Domyślnie instalowana jest najnowsza stabilna wersja dla 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) i is_keras_available()

library(keras) ładuje powiązania R. Po załadowaniu należy sprawdzić, czy backend Keras/TF dla Pythona jest rzeczywiście dostępny, używając is_keras_available(). Funkcja zwraca TRUE, jeśli TensorFlow jest zainstalowany i można go zaimportować, albo FALSE wraz z pomocnym komunikatem, jeśli brakuje środowiska Pythona.

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

Pakiet tensorflow

Pakiet R tensorflow zapewnia bezpośredni dostęp do interfejsu API TensorFlow dla Pythona za pośrednictwem reticulate. install_tensorflow() działa podobnie jak install_keras(), ale instaluje wyłącznie TensorFlow, bez dodatków Keras. Należy go użyć, gdy potrzebują Państwo niskopoziomowych operacji 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() — identyfikowanie backendu

k_backend() zwraca ciąg znaków identyfikujący backend używany przez Keras. Współczesny Keras R (keras3) zawsze korzysta z TensorFlow. Starsza wersja keras (v2) mogła również używać Theano lub CNTK. Znajomość backendu jest przydatna podczas diagnozowania problemów ze środowiskiem.

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'

Sprawdzanie dostępności GPU

Trenowanie na GPU może być 10–50 razy szybsze niż na CPU w przypadku dużych sieci. Dostępność GPU można sprawdzić, a wykryte urządzenia wyświetlić za pomocą interfejsu urządzeń TensorFlow. Jeśli mają Państwo kartę NVIDIA GPU i zainstalowane CUDA, TensorFlow użyje jej automatycznie.

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

Zarządzanie środowiskiem Pythona

W tle R keras używa pakietu reticulate do wywoływania Pythona. Za pomocą reticulate::use_condaenv() lub reticulate::use_virtualenv() można wybrać środowisko Pythona, w którym zainstalowano TensorFlow. Należy wywołać tę funkcję przed załadowaniem 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__)

Różnice między interfejsami API keras3 i keras2

Pakiet R keras przeszedł gruntowne przepisanie w wersji 3 (keras3), wydanej w 2024 roku. Nowy interfejs API używa keras_model_sequential() zamiast keras_model_sequential() |> oraz stylu dodawania warstw opartego na potoku. Starszy kod używa %>%, a współczesny kod — natywnego potoku 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)

Weryfikowanie kompletnej konfiguracji

Przed utworzeniem dowolnego modelu należy przeprowadzić szybką weryfikację całego procesu: utworzyć niewielki model, skompilować go i wytrenować na danych syntetycznych. Jeśli proces zakończy się bez błędów, konfiguracja Keras + TF działa prawidłowo.

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

Zarządzanie sesją i pamięcią

TensorFlow intensywnie wykorzystuje GPU i pamięć RAM. W interaktywnych sesjach R należy wywołać keras::backend()$clear_session(), aby zwolnić pamięć podczas zmiany eksperymentów. Aby zapewnić odtwarzalność wyników, należy ustawić ziarna losowości TF i R przed utworzeniem modeli.

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

Przegląd procesu pracy

Typowy proces pracy związany z uczeniem głębokim w R obejmuje następujące kroki:

Instalacja: install_keras() raz na komputerze
Ładowanie: library(keras)
Przygotowanie danych: normalizacja cech, konwersja do macierzy
Budowa modelu: keras_model_sequential() + warstwy
Kompilacja: określenie funkcji straty, optymalizatora i metryk
Trenowanie: fit(model, x, y, epochs, callbacks)
Ewaluacja/predykcja: 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)

Szybkie sprawdzenie

Co robi wywołanie install_keras() w R?

Podsumowanie konfiguracji Keras

Najważniejsze informacje z lekcji „Konfigurowanie Keras i TensorFlow w R”:

install_keras() tworzy środowisko Pythona i instaluje TensorFlow — należy uruchomić tę funkcję raz na komputerze.
is_keras_available() sprawdza, czy backend jest dostępny przed rozpoczęciem trenowania.
k_backend() identyfikuje backend (we współczesnym keras zawsze jest nim TensorFlow).
Dostępność GPU sprawdza się za pomocą tf$config$list_physical_devices('GPU').
Za pomocą reticulate::use_condaenv() należy wybrać właściwe środowisko Pythona.
Aby zapewnić odtwarzalność wyników, należy ustawić ziarna za pomocą set.seed() i tensorflow::set_random_seed().
Między eksperymentami należy wywoływać backend()$clear_session(), aby zwolnić pamięć.

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

Często zadawane pytania

Czy lekcja „Konfiguracja Keras i TensorFlow w R” jest bezpłatna?

Tak — pełny tekst „Konfiguracja Keras i TensorFlow w R” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Konfiguracja Keras i TensorFlow w R”?

Zainstaluj pakiet R keras, skonfiguruj backend Pythona i sprawdź poprawność konfiguracji. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Konfiguracja Keras i TensorFlow w R”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Konfiguracja Keras i TensorFlow w R
Budowanie modeli sekwencyjnych
Podstawy konwolucyjnych sieci neuronowych
Trenowanie, walidacja i zapobieganie przeuczeniu

← Powrót do R Academy