knit guides and examples

Author: t-kalinowski

man/layer_tfsm.Rd

@@ -42,7 +42,7 @@ Let's see how that works.
 ## Setup
 
 
-```r
+``` r
 library(reticulate)
 library(tensorflow, exclude = c("set_random_seed", "shape"))
 library(keras3)
@@ -74,11 +74,10 @@ to update the state of the metrics that were passed in `compile()`,
 and we query results from `self$metrics` at the end to retrieve their current value.
 
 
-```r
+``` r
 CustomModel <- new_model_class(
   "CustomModel",
   train_step = function(data) {
-    # unpack data into x, y, and sample_weight
     c(x, y = NULL, sample_weight = NULL) %<-% data
 
     with(tf$GradientTape() %as% tape, {
@@ -113,7 +112,7 @@ CustomModel <- new_model_class(
 Let's try this out:
 
 
-```r
+``` r
 # Construct and compile an instance of CustomModel
 inputs <- keras_input(shape = 32)
 outputs <- layer_dense(inputs, 1)
@@ -128,7 +127,7 @@ model |> fit(x, y, epochs = 3)
 
 ```
 ## Epoch 1/3
-## 32/32 - 1s - 23ms/step - loss: 2.9118 - mae: 1.3597
+## 32/32 - 1s - 19ms/step - loss: 2.9118 - mae: 1.3597
 ## Epoch 2/3
 ## 32/32 - 0s - 1ms/step - loss: 2.6026 - mae: 1.2856
 ## Epoch 3/3
@@ -154,7 +153,7 @@ on any object listed here at the beginning of each `fit()` epoch or at the begin
 `evaluate()`.
 
 
-```r
+``` r
 CustomModel <- new_model_class(
   "CustomModel",
   initialize = function(...) {
@@ -164,7 +163,6 @@ CustomModel <- new_model_class(
     self$loss_fn <- loss_mean_squared_error()
   },
   train_step = function(data) {
-    # unpack data into x, y, and sample_weight
     c(x, y = NULL, sample_weight = NULL) %<-% data
 
     with(tf$GradientTape() %as% tape, {
@@ -214,11 +212,11 @@ model |> fit(x, y, epochs = 3)
 
 ```
 ## Epoch 1/3
-## 32/32 - 1s - 19ms/step - loss: 2.6540 - mae: 1.2901
+## 32/32 - 1s - 16ms/step - loss: 2.6540 - mae: 1.2901
 ## Epoch 2/3
-## 32/32 - 0s - 2ms/step - loss: 2.4139 - mae: 1.2303
+## 32/32 - 0s - 1ms/step - loss: 2.4139 - mae: 1.2303
 ## Epoch 3/3
-## 32/32 - 0s - 2ms/step - loss: 2.2080 - mae: 1.1761
+## 32/32 - 0s - 1ms/step - loss: 2.2080 - mae: 1.1761
 ```
 
 ## Supporting `sample_weight` & `class_weight`
@@ -233,11 +231,10 @@ it manually if you don't rely on `compile()` for losses & metrics)
 - That's it.
 
 
-```r
+``` r
 CustomModel <- new_model_class(
   "CustomModel",
   train_step = function(data) {
-    # unpack data into x, y, and sample_weight
     c(x, y = NULL, sample_weight = NULL) %<-% data
 
     with(tf$GradientTape() %as% tape, {
@@ -285,11 +282,11 @@ model |> fit(x, y, sample_weight = sw, epochs = 3)
 
 ```
 ## Epoch 1/3
-## 32/32 - 1s - 21ms/step - loss: 0.1607 - mae: 1.3018
+## 32/32 - 1s - 18ms/step - loss: 0.1607 - mae: 1.3018
 ## Epoch 2/3
 ## 32/32 - 0s - 1ms/step - loss: 0.1452 - mae: 1.2999
 ## Epoch 3/3
-## 32/32 - 0s - 2ms/step - loss: 0.1335 - mae: 1.2986
+## 32/32 - 0s - 1ms/step - loss: 0.1335 - mae: 1.2986
 ```
 
 ## Providing your own evaluation step
@@ -298,7 +295,7 @@ What if you want to do the same for calls to `model.evaluate()`? Then you would
 override `test_step` in exactly the same way. Here's what it looks like:
 
 
-```r
+``` r
 CustomModel <- new_model_class(
   "CustomModel",
   test_step = function(data) {
@@ -335,7 +332,7 @@ model |> evaluate(x, y)
 ```
 
 ```
-## 32/32 - 0s - 9ms/step - loss: 0.0000e+00 - mae: 1.3947
+## 32/32 - 0s - 8ms/step - loss: 0.0000e+00 - mae: 1.3947
 ```
 
 ```
@@ -359,7 +356,7 @@ Let's consider:
 - A loss function to train the discriminator.
 
 
-```r
+``` r
 # Create the discriminator
 discriminator <-
   keras_model_sequential(name = "discriminator", input_shape = c(28, 28, 1)) |>
@@ -402,7 +399,7 @@ Here's a feature-complete GAN class, overriding `compile()` to use its own signa
 and implementing the entire GAN algorithm in 17 lines in `train_step`:
 
 
-```r
+``` r
 GAN <- Model(
   classname = "GAN",
 
@@ -480,7 +477,7 @@ GAN <- Model(
 Let's test-drive it:
 
 
-```r
+``` r
 batch_size <- 64
 c(c(x_train, .), c(x_test, .)) %<-% dataset_mnist()
 all_digits <- op_concatenate(list(x_train, x_test))
@@ -510,7 +507,7 @@ gan |> fit(
 ```
 
 ```
-## 100/100 - 5s - 53ms/step - d_loss: 0.0000e+00 - g_loss: 0.0000e+00
+## 100/100 - 5s - 47ms/step - d_loss: 0.0000e+00 - g_loss: 0.0000e+00
 ```
 
 The ideas behind deep learning are simple, so why should their implementation be painful?

vignettes/custom_train_step_in_tensorflow.Rmd

@@ -40,7 +40,7 @@ industry workflows.
 
 
 
-```r
+``` r
 library(keras3)
 library(tensorflow, exclude = c("shape", "set_random_seed"))
 library(tfdatasets, exclude = "shape")
@@ -90,7 +90,7 @@ in a multi-device or distributed workflow.
 Schematically, it looks like this:
 
 
-```r
+``` r
 # Create a MirroredStrategy.
 strategy <- tf$distribute$MirroredStrategy()
 cat(sprintf('Number of devices: %d\n', strategy$num_replicas_in_sync))
@@ -113,7 +113,7 @@ with(startegy$scope(), {
 Here's a simple end-to-end runnable example:
 
 
-```r
+``` r
 get_compiled_model <- function() {
   inputs <- keras_input(shape = 784)
   outputs <- inputs |>
@@ -173,7 +173,7 @@ cat(sprintf('Number of devices: %d\n', strategy$num_replicas_in_sync))
 ## Number of devices: 2
 ```
 
-```r
+``` r
 # Open a strategy scope.
 with(strategy$scope(), {
   # Everything that creates variables should be under the strategy scope.
@@ -193,10 +193,10 @@ with(strategy$scope(), {
 
 ```
 ## Epoch 1/2
-## 782/782 - 6s - 7ms/step - loss: 3.0622 - sparse_categorical_accuracy: 0.8615 - val_loss: 1.1367 - val_sparse_categorical_accuracy: 0.9006
+## 782/782 - 5s - 7ms/step - loss: 3.0622 - sparse_categorical_accuracy: 0.8615 - val_loss: 1.1367 - val_sparse_categorical_accuracy: 0.9006
 ## Epoch 2/2
 ## 782/782 - 3s - 4ms/step - loss: 0.5774 - sparse_categorical_accuracy: 0.9259 - val_loss: 0.6612 - val_sparse_categorical_accuracy: 0.9210
-## 157/157 - 0s - 3ms/step - loss: 0.6729 - sparse_categorical_accuracy: 0.9150
+## 157/157 - 0s - 2ms/step - loss: 0.6729 - sparse_categorical_accuracy: 0.9150
 ```
 
 ```
@@ -218,7 +218,7 @@ training from your saved model.
 Here's a simple example:
 
 
-```r
+``` r
 # Prepare a directory to store all the checkpoints.
 checkpoint_dir <- "./ckpt"
 if (!dir.exists(checkpoint_dir)) {
@@ -274,10 +274,10 @@ run_training(epochs = 1)
 ```
 
 ```
-## 782/782 - 6s - 7ms/step - loss: 2.9519 - sparse_categorical_accuracy: 0.8655 - val_loss: 1.3110 - val_sparse_categorical_accuracy: 0.8836
+## 782/782 - 4s - 6ms/step - loss: 2.9519 - sparse_categorical_accuracy: 0.8655 - val_loss: 1.3110 - val_sparse_categorical_accuracy: 0.8836
 ```
 
-```r
+``` r
 # Calling the same function again will resume from where we left off
 run_training(epochs = 1)
 ```

vignettes/distributed_training_with_tensorflow.Rmd

@@ -42,7 +42,7 @@ clients, while preserving its global semantics.
 ## Setup
 
 
-```r
+``` r
 # This guide assumes there are 8 GPUs available for testing. If you don't have
 # 8 gpus available locally, you can set the following envvar to
 # make xla initialize the CPU as 8 devices, to enable local testing
@@ -52,7 +52,7 @@ Sys.setenv("XLA_FLAGS" = "--xla_force_host_platform_device_count=8")
 
 
 
-```r
+``` r
 library(keras3)
 
 # The distribution API is only implemented for the JAX backend for now.
@@ -79,7 +79,7 @@ You can find more detailed concept explainers in the
 [TensorFlow DTensor guide](https://www.tensorflow.org/guide/dtensor_overview#dtensors_model_of_distributed_tensors).
 
 
-```r
+``` r
 # Retrieve the local available gpu devices.
 devices <- jax$devices() # "gpu"
 str(devices)
@@ -97,7 +97,7 @@ str(devices)
 ##  $ :TFRT_CPU_7
 ```
 
-```r
+``` r
 # Define a 2x4 device mesh with data and model parallel axes
 mesh <- keras$distribution$DeviceMesh(
   shape = shape(2, 4),
@@ -140,7 +140,7 @@ portion of the input data.
 
 Here is a sample usage of this class.
 
-```r
+``` r
 # Create DataParallel with list of devices.
 # As a shortcut, the devices can be skipped,
 # and Keras will detect all local available devices.
@@ -184,14 +184,14 @@ model |> fit(dataset, epochs = 3)
 
 ```
 ## Epoch 1/3
-## 8/8 - 0s - 47ms/step - loss: 1.0629
+## 8/8 - 0s - 37ms/step - loss: 1.0629
 ## Epoch 2/3
-## 8/8 - 0s - 7ms/step - loss: 0.9712
+## 8/8 - 0s - 5ms/step - loss: 0.9712
 ## Epoch 3/3
-## 8/8 - 0s - 7ms/step - loss: 0.9322
+## 8/8 - 0s - 5ms/step - loss: 0.9322
 ```
 
-```r
+``` r
 model |> evaluate(dataset)
 ```
 
@@ -235,7 +235,7 @@ multiple matches, a `ValueError` is raised. If no matches are found, `NULL` is
 returned.
 
 
-```r
+``` r
 mesh_2d <- keras$distribution$DeviceMesh(
   shape = shape(2, 4),
   axis_names = c("data", "model"),
@@ -280,17 +280,17 @@ model |> fit(dataset, epochs = 3)
 ## Epoch 1/3
 ## 8/8 - 0s - 29ms/step - loss: 1.0714
 ## Epoch 2/3
-## 8/8 - 0s - 4ms/step - loss: 0.9744
+## 8/8 - 0s - 3ms/step - loss: 0.9744
 ## Epoch 3/3
-## 8/8 - 0s - 5ms/step - loss: 0.9280
+## 8/8 - 0s - 4ms/step - loss: 0.9280
 ```
 
-```r
+``` r
 model |> evaluate(dataset)
 ```
 
 ```
-## 8/8 - 0s - 9ms/step - loss: 0.8802
+## 8/8 - 0s - 7ms/step - loss: 0.8802
 ```
 
 ```
@@ -304,7 +304,7 @@ more data parallel or model parallel. You can do this by adjusting the shape of
 the mesh. And no changes are needed for any other code.
 
 
-```r
+``` r
 full_data_parallel_mesh <- keras$distribution$DeviceMesh(
   shape = shape(8, 1),
   axis_names = list("data", "model"),

vignettes/distribution.Rmd

@@ -1,7 +1,7 @@
 ---
 title: Keras examples
 output: rmarkdown::html_vignette
-date: 'Last Modified: 2023-11-30; Last Rendered: 2024-05-16'
+date: 'Last Modified: 2023-11-30; Last Rendered: 2024-05-21'
 vignette: >
   %\VignetteIndexEntry{Keras examples}
   %\VignetteEngine{knitr::rmarkdown}

vignettes/examples/index.Rmd

@@ -583,7 +583,7 @@ transformer |> fit(train_ds, epochs = epochs,
 ```
 
 ```
-## 1297/1297 - 56s - 43ms/step - accuracy: 0.7708 - loss: 1.5755 - val_accuracy: 0.7784 - val_loss: 1.3806
+## 1297/1297 - 58s - 44ms/step - accuracy: 0.7709 - loss: 1.5752 - val_accuracy: 0.7731 - val_loss: 1.4209
 ```