Overview | Quick Search | Example: Finding a Photovoltaic Dataset | Complete Catalog | Collections | Biology Collection (9 datasets) | Medical Collection (8 datasets) | Infrared Collection (4 datasets) | Damage Collection (3 datasets) | Underwater Collection (4 datasets) | Document Collection (6 datasets) | Usage Example | Dataset Statistics | Filtering and Exploration | Additional Resources | Citation

Introduction | Setup | A first simple example | Going lower-level | Supporting sample_weight & class_weight | Providing your own evaluation step | Wrapping up: an end-to-end GAN example

Introduction | How it works | Setup | DeviceMesh and TensorLayout | Distribution | DataParallel | ModelParallel and LayoutMap | Further reading

Overview | Installation | MNIST Example | Preparing the Data | Defining the Model | Training and Evaluation | Deep Learning with R Book | Why this name, Keras?

Introduction | Setup | A first example: A MNIST convnet | Writing cross-framework custom components | Training models on arbitrary data sources | Further reading | How to customize what happens in fit() | How to write custom training loops | How to distribute training

Introduction | Setup | The Layer class: the combination of state (weights) and some computation | Layers can have non-trainable weights | Best practice: deferring weight creation until the shape of the inputs is known | Layers are recursively composable | Backend-agnostic layers and backend-specific layers | The add_loss() method | You can optionally enable serialization on your layers | Privileged training argument in the call() method | Privileged mask argument in the call() method | The Model class | Putting it all together: an end-to-end example

Introduction | Setup | Single-host, multi-device synchronous training | Using callbacks to ensure fault tolerance | tf$data performance tips

Setup | Introduction | Training, evaluation, and inference | Save and serialize | Use the same graph of layers to define multiple models | All models are callable, just like layers | Manipulate complex graph topologies | Models with multiple inputs and outputs | A toy ResNet model | Shared layers | Extract and reuse nodes in the graph of layers | Extend the API using custom layers | When to use the functional API | Functional API strengths: | Less verbose | Model validation while defining its connectivity graph | A functional model is plottable and inspectable | A functional model can be serialized or cloned | Functional API weakness: | It does not support dynamic architectures | Mix-and-match API styles

Setup | Introduction | API overview: a first end-to-end example | The compile() method: specifying a loss, metrics, and an optimizer | Many built-in optimizers, losses, and metrics are available | Custom losses | Custom metrics | Handling losses and metrics that don't fit the standard signature | Automatically setting apart a validation holdout set | Training & evaluation using TF Dataset objects | Using sample weighting and class weighting | Class weights | Sample weights | Passing data to multi-input, multi-output models | Using callbacks | Many built-in callbacks are available | Writing your own callback | Checkpointing models | Using learning rate schedules | Passing a schedule to an optimizer | Using callbacks to implement a dynamic learning rate schedule | Visualizing loss and metrics during training with TensorBoard | Using the TensorBoard callback

Setup | Introduction | Freezing layers: understanding the trainable attribute | Recursive setting of the trainable attribute | The typical transfer-learning workflow | Fine-tuning | An end-to-end example: fine-tuning an image classification model on a cats vs. dogs dataset | Getting the data | Standardizing the data | Using random data augmentation | Build a model | Train the top layer | Do a round of fine-tuning of the entire model

Setup | Introduction | Using the GradientTape: a first end-to-end example | Low-level handling of metrics | Speeding-up your training step with tf_function() | Low-level handling of losses tracked by the model | Summary | End-to-end example: a GAN training loop from scratch

Windows | CPU | GPU | MacOS | Linux | Installing from pre-built binaries | Using cudatoolkit R packages | Environment variables | Troubleshooting | Debug installation messages | Large file download timeout | File based download | Installing older versions

Overview | Installation | MNIST Example | Preparing the Data | Defining the Model | Training and Evaluation | Deep Learning with R Book | Why this name, Keras?

First example: a densely-connected network | All models are callable, just like layers | Multi-input and multi-output models | Shared layers | The concept of layer "node" | More examples | Inception module | Residual connection on a convolution layer | Shared vision model | Visual question answering model | Video question answering model

Defining a Model | Input Shapes | Compilation | Training | Examples | Multilayer Perceptron (MLP) for multi-class softmax classification | MLP for binary classification | VGG-like convnet | Sequence classification with LSTM | Sequence classification with 1D convolutions: | Stacked LSTM for sequence classification | Same stacked LSTM model, rendered "stateful"

Overview | Setup | Saving Sequential Models or Functional models | Whole-model saving | Export to SavedModel | Architecture-only saving | Weights-only saving | Weights-only saving in SavedModel format | Saving Subclassed Models

Declaring Python Requirements with py_require() | Unsatisfiable requirements. | Manually managing Python installations | ⚠ Updated Guidance | Overview | Python environments | Simple Installation | Virtualenv installation | Conda installation | Shell installation

Introduction | How to save and load a model | Setup | Saving | APIs | Custom objects | Registering custom objects (preferred) | Passing custom objects to load_model() | Using a custom object scope | Model serialization | In-memory model cloning | get_config() and from_config() | save_model_config() and load_model_config() | Arbitrary object serialization and deserialization | Model weights saving | APIs for in-memory weight transfer | APIs for saving weights to disk & loading them back | Transfer learning example | Appendix: Handling custom objects | Defining the config methods | How custom objects are serialized

Introduction | Setup | Keras callbacks overview | An overview of callback methods | Global methods | on_(train|test|predict)_begin(logs = NULL) | on_(train|test|predict)_end(logs = NULL) | Batch-level methods for training/testing/predicting | on_(train|test|predict)_batch_begin(batch, logs = NULL) | on_(train|test|predict)_batch_end(batch, logs = NULL) | Epoch-level methods (training only) | on_epoch_begin(epoch, logs = NULL) | on_epoch_end(epoch, logs = NULL) | A basic example | Usage of logs list | Usage of self$model attribute | Examples of Keras callback applications | Early stopping at minimum loss | Learning rate scheduling | Built-in Keras callbacks

Getting Started with ragnar | Why RAG? The Hallucination Problem | Use Case: Quarto Docs Chat vs. Standard Search | Setting up RAG | Creating the Store | Identify Documents for Processing | Convert Documents to Markdown | Chunk and Augment | Insert in the Store | Tying it Together | Retrieval | Customizing Retrieval | Troubleshooting and Debugging | Cost Management | Summary

Tags in YAML and how yaml12 handles them | Using handlers to transform tagged nodes while parsing | Post-process tags yourself | Mappings revisited: non-string keys and yaml_keys | Tagged mapping keys | Document Streams and Markers | Reading Multiple Documents | Writing Multiple Documents | Writing YAML with tags | Anchors | Debugging | (Very) Advanced Tags | Tag directives (%TAG) | TAG URIs | Core schema tags

A first example | Comments | Collections | Sequences: YAML’s ordered collections | Mappings: key/value pairs | Scalars | Block scalars | Quoted scalars | Plain (unquoted) scalars | End-to-end example | Quick notes

Overview | Dataset Preparation | Estimator Construction | Input Function | Training and Evaluation | Learning More

Model Deployment | Exporting a SavedModel | Deploying the Model | Prediction

Overview | Google Cloud Account | Installation | Training on CloudML | Submitting a Job | Collecting Results | Training with a GPU | Learning More

Overview | Copying Data | Reading Data | Data Source Configuration | Managing Storage | Google Storage Browser | Google Cloud SDK

Overview | What's a hyperparameter? | How it works | What it optimizes | How Cloud ML Engine gets your metric | The flow of hyperparameter values | Selecting hyperparameters | Preparing your script | Tuning configuration | Submitting a tuning job | Collecting trials | Optimization metrics

Overview | Local Development | Submitting Jobs | Collecting Job Results | Training Runs | Managing Jobs | Tuning Your Application | Training with a GPU | Training Configuration | Learning More

Setup | When to use a Sequential model | Creating a Sequential model | Specifying the input shape in advance | A common debugging workflow: add layers + summary() | What to do once you have a model | Feature extraction with a Sequential model | Transfer learning with a Sequential model

Declaring Python Requirements | Typical Usage | Best Practices | Declaring Optional Dependencies | Delay Loading Python Modules | Installing Python Dependencies | Checking and Testing on CRAN | Implementing S3 Methods | Supporting Versions with Different S3 Classes | Converting between R and Python | Writing your own r_to_py() methods | Using GitHub Actions

⚠ Deprecated Vignette | Creating a "Pit of Success" | Managing Multiple Package Dependencies | Automatic Configuration | Using Config/reticulate | Installation | .onLoad Configuration | Versions | Format

⚠ Updated Guidance | Locating Python | Providing Hints | Order of Discovery | Python Packages | Configuration Info

Setup | Introduction | Padding sequence data | Masking | Mask-generating layers: Embedding and Masking | Mask propagation in the Functional API and Sequential API | Passing mask tensors directly to layers | Supporting masking in your custom layers | Opting-in to mask propagation on compatible layers | Writing layers that need mask information | Summary

Column-major order | Row-major order | Python | Displaying arrays | Reticulate with care | Another example | What about going from R column-major arrays to Python? | But the array I created in R ends up transposed compared to ones I create in Python? | Reshaping arrays | Other differences warranting caution | Addressing an issue that came up

Overview | Python Version | Python Packages | Type Conversions | Importing Modules | Sourcing Scripts | Executing Code | Object Conversion | Getting Help | Lists, Tuples, and Dictionaries | Numeric Types and Indexes | Arrays | Data Frames | Using Pandas nullable data types | Sparse Matrices | With Contexts | Iterators | Element Level Iteration | Generators | Functions | Signatures | Background Threads | Advanced | Python Objects | Pickle | Configuration | Output Control | Miscellaneous | Learning More

Primer on Python for R users | Whitespace | Container Types | Lists | Tuples | Packing and Unpacking | Dictionaries | Sets | Iteration with for | Comprehensions | Defining Functions with def | Defining Classes with class | What are all the underscores? | Iterators, revisited | Defining Generators with yield. | Iteration closing remarks | import and Modules | Where are modules found? | Integers and Floats | What about R vectors? | Decorators | with and context management | Learning More

Overview | Python Version | Python Chunks | Calling Python from R | Calling R from Python | Engine Setup

Setup | Introduction | Tensors | Variables | Doing math in TensorFlow | Gradients | Keras layers | Layer weight creation in build(input_shape) | Layer gradients | Trainable and non-trainable weights | Layers that own layers | Tracking losses created by layers | Keeping track of training metrics | Compiled functions | Training mode & inference mode | The Functional API for model-building | End-to-end experiment example 1: variational autoencoders. | End-to-end experiment example 2: hypernetworks.

Overview | Installation | Creating a Dataset | Text Files | Parallel Decoding | TFRecords Files | SQLite Databases | Transformations | Mapping | Parallel Mapping | Filtering | Features and Response | Shuffling and Batching | Prefetching | Complete Example | Reading Datasets | keras package | tensorflow package | Reading Multiple Files | Multiple Machines

Multiple optimizers | Fully flexible step | Next steps

Training a nn_module | The training loop | Metrics | Evaluate | Customizing with callbacks | Next steps

How should I cite Keras? | How can I run Keras on a GPU? | TensorFlow | Theano | CNTK | How can I run a Keras model on multiple GPUs? | Data parallelism | Device parallelism | What does "sample", "batch", "epoch" mean? | Why are Keras objects modified in place? | How can I save a Keras model? | Saving/loading whole models (architecture + weights + optimizer state) | Saving/loading only a model's architecture | Saving/loading only a model's weights | Why is the training loss much higher than the testing loss? | How can I obtain the output of an intermediate layer? | How can I use Keras with datasets that don't fit in memory? | Generator Functions | External Data Generators | Image Generators | Batch Functions | How can I interrupt training when the validation loss isn't decreasing anymore? | How is the validation split computed? | Is the data shuffled during training? | How can I record the training / validation loss / accuracy at each epoch? | How can I "freeze" Keras layers? | How can I use stateful RNNs? | How can I remove a layer from a Sequential model? | How can I use pre-trained models in Keras? | How can I use other Keras backends? | How can I use the PlaidML backend? | How can I use Keras in another R package? | Testing on CRAN | Keras Module | Custom Layers | How can I obtain reproducible results using Keras during development? | Where is the Keras configuration filed stored?

Import keras | Build a simple model | Sequential model | Configure the layers | Train and evaluate | Set up training | Input data | Evaluate and predict | Build advanced models | Functional API | Custom layers | Custom models | Callbacks | Save and restore | Weights only | Configuration only | Entire model

Overview | Plotting History | RStudio IDE | TensorBoard | Recording Data | Viewing Data | Comparing Runs | Customization | Metrics | Options

Applications | Usage Examples | Classify ImageNet classes with ResNet50 | Extract features with VGG16 | Extract features from an arbitrary intermediate layer with VGG19 | Fine-tune InceptionV3 on a new set of classes | Build InceptionV3 over a custom input tensor | Additional examples

The Layer function | Best practice: deferring weight creation until the shape of the inputs is known | Layers are recursively composable | Layers recursively collect losses created during the forward pass | You can optionally enable serialization on your layers | Privileged training argument in the call method

Installation | Training | Comparing Runs | Analyzing Runs | RStudio IDE | Addin | Background Training | Publishing Reports | Hyperparameter Tuning | Managing Runs

Example

Installation | Loading modules | Using with Keras | Using with tfdatasets | Using with recipes | tfhub.dev

Setup | An ImageNet classifier | Download the classifier | Run it on a single image | Simple transfer learning | Dataset | Download the headless model | Attach a classification head | Train the model

An Abalone Age Predictor | Setup | Downloading and Loading Abalone CSV Data | Instantiating an Estimator | Constructing the model_fn | Configuring a neural network with feature_column and layers | Defining loss for the model | Defining the training op for the model | The complete abalone model_fn | Running the Abalone Model

Getting Started | Intro to Convolutional Neural Networks | Building the CNN MNIST Classifier | Input Layer | Convolutional Layer #1 | Pooling Layer #1 | Convolutional Layer #2 and Pooling Layer #2 | Dense Layer | Logits Layer | Generate Predictions | Calculate Loss | Configure the Training Op | Add evaluation metrics | Training and Evaluating the CNN MNIST Classifier | Load Training and Test Data | Create the Estimator | Set Up a Logging Hook | Train the Model | Evaluate the Model | Run the Model

Overview | Canned Estimators | Input Functions | Feature Columns | Creating an Estimator | Training and Prediction | Model Persistence | Generic methods

Overview | Pattern Matching

Overview | Training Flags | Tuning Runs | Experiment Scopes | Sampling Flag Combinations

Overview | Built in Callbacks | Custom Callbacks | Fields | Methods

Overview | Creating a Custom Model | Using a Custom Model

Using a Module | Instantiating a Module | Caching Modules | Applying a Module | Creating a new Module | General approach | Fine-Tuning | For consumers | For publishers | Hosting a Module | Protocol

Run Output | Cleaning Runs | Purging Runs

Overview | Data Frame Input | Training vs. Evaluation | Matrix Input | List Input

Overview | Built-in Run Hooks | Custom Run Hooks

Overview | Examples

Overview | Example output of parsing spec | Example usage with a classifier