torch

torch Package

PyTorch-style deep learning in R.

Tensors

library(torch)

# Create tensors
x <- torch_tensor(c(1, 2, 3))
x <- torch_randn(3, 4)
x <- torch_zeros(2, 3)
x <- torch_ones(2, 3)

# Operations
y <- x + 1
z <- torch_matmul(x, y$t())

# GPU
if (cuda_is_available()) {
  x <- x$cuda()
}

Define Model

net <- nn_module(
  initialize = function(input_size, hidden_size, output_size) {
    self$fc1 <- nn_linear(input_size, hidden_size)
    self$fc2 <- nn_linear(hidden_size, output_size)
  },
  forward = function(x) {
    x %>%
      self$fc1() %>%
      nnf_relu() %>%
      self$fc2()
  }
)

model <- net(input_size = 10, hidden_size = 64, output_size = 1)

Training Loop

optimizer <- optim_adam(model$parameters, lr = 0.001)
loss_fn <- nn_mse_loss()

for (epoch in 1:100) {
  optimizer$zero_grad()

  output <- model(x_train)
  loss <- loss_fn(output, y_train)

  loss$backward()
  optimizer$step()

  if (epoch %% 10 == 0) {
    cat("Epoch:", epoch, "Loss:", loss$item(), "\n")
  }
}

Dataset & DataLoader

dataset <- dataset(
  initialize = function(x, y) {
    self$x <- torch_tensor(x)
    self$y <- torch_tensor(y)
  },
  .getitem = function(i) {
    list(x = self$x[i, ], y = self$y[i])
  },
  .length = function() {
    self$x$size(1)
  }
)

ds <- dataset(x_data, y_data)
dl <- dataloader(ds, batch_size = 32, shuffle = TRUE)

for (batch in enumerate(dl)) {
  # batch$x, batch$y
}

Save/Load

torch_save(model, "model.pt")
model <- torch_load("model.pt")