R で Keras と TensorFlow をセットアップする

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

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)

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

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)

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'

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

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

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)

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

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

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

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