Inferring package sources | Unknown sources | Custom R package repositories | Repository snapshots | Bioconductor | Initializing a project | Bioconductor releases | Bioconductor mirrors | Disabling Bioconductor | The package cellar | Explicit sources | ABI compatibility | Build-time dependencies

Why isn't my package being snapshotted into the lockfile? | Capturing all dependencies | Capturing explicit dependencies | How do I update the lockfile? | How should I handle development dependencies? | I'm returning to an older renv project. What do I do? | How can I check my packages for known vulnerabilities? | Why are package downloads failing?

Cache | Cache location | Multiple caches | Shared cache locations | Caveats | Building from source | Configure flags | Install flags | Vignettes | Downloads | Alternative downloaders | Proxies | Authentication | Azure DevOps | Git and Personal Access Tokens | Custom headers | Debugging

Publishing from the RStudio IDE | Publishing programatically | A word about packrat

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

Overview | User Guide | Going further with examples

Overview | Tutorials | User Guide | Going further with examples | Cheatsheets

Pagebreaks | Using with PDF/ latex documents | Using with HTML documents | Using with Word documents | Using with ODT documents | Number sections | Custom environment for LaTeX | About Lua filters | Using filters with output format

Introduction | Usage | Managing profile-specific dependencies | Profile-specific ignore rules

GitHub actions | Using r-lib/actions/setup-renv | Using the GitHub Actions Cache with renv | Generating a lockfile in CI | Downloading packages in CI | GitLab CI

Containerizing an existing renv project | Caching package installs | Basic Docker layer cache | Cache mounts | Bind-mounted host caches | System dependencies | Multi-stage builds

Libraries and repositories | Getting started | Collaboration | Installing packages | Updating packages | Infrastructure | Caveats | Uninstalling renv

Activating Python integration | Deactivating Python integration | Understanding Python integration | Virtual environments | Conda environments

Getting started | Reading and writing data | How and what to store as a pin | Metadata | Versioning | Reading and writing files | Caching

Why test Shiny applications? | How testing works with shinytest2 | Getting started | Recording tests | Running tests | Subsequent test runs | Multiple test scripts | Interactive R Markdown documents | Randomness | One .Rmd file per directory | Prerendered Shiny documents | Next

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

What does it mean when I run test_app() and it says, "Server did not update any output values within 3 seconds"? | Some input values are not set right after calling app$set_inputs(). How do I wait for them? | How can my app detect if it's running in {shinytest2}? | How can I get the objects from files in my the R folder into the testing environment? | Can I modify the input and output values that are recorded in snapshots? | Should I manually shut down my AppDriver? | How can I open the test to see if bookmarks are working?

Applications defined in another file | Applications using a function | Application objects | Understanding app support files: local_app_support() and friends | When do you need these functions? | Which function should you use? | Benefits of using these functions | Other setup steps | How should I test multiple applications? | Migrating from shinytest v0.4.0 to v0.5.0 | Continuous integration

Audit Shiny apps with | Introduction | Load testing with | Launch the background app | Connect Chrome | Replay with shinycannon | Report generation | Automating with GitHub Actions

Monkey (headless) testing with | Initialize the driver | Injecting gremlins.js | Easy way | Local way | Unleash the horde | A bit about gremlins.js | Practice | Blind run | Optimized testing

Expectations | Confirm the expected behavior | Assert as little unnecessary information | Write clear, direct tests | {shinytest2} expectations | input/output names | Shiny values: | Downloads | UI expectations | UI visual expectations | Suggested approaches | Exported values | Snapshots vs values | Example | Cliffs Notes | Retrieving values | Expectation methods

Customizing test scripts | Setting inputs with app$set_inputs() and app$click() | Making expectations | Exported values | Adding delays | Controlling random values | Widgets | Tabs | Uploading files | View the headless browser | Getting input, output, and export values | Waiting for an input (or output) value | Dealing with dynamic data | Using variant to expect different snapshots | Limitations | Inputs without input bindings | Input component(s) provided as variable(s) | Next

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

Introduction | Full example

Create a vetiver_model() | Store and version your model | Deploy your model | Predict from your model endpoint

Summary | Introduction | Understanding the module namespace issue | Enabling and disabling shiny modules support | Backward Compatibility

Saving things is hard | Native serialization, and where it falls short | Using bundle

Detecting RStudio | Session Interaction | Running at Startup

A function to store factors | A function to read factors | Examples of using consistent metadata

Upload a single file | Function to manage uploading | Another example: upload a zipped directory archive as a pin

Sharing tidied data | Automating | Shiny apps

Examples | Pinning files | Pinning a url | Implicit board | Equivalents | Board functions | Pin functions

Publishing | Consuming | Publishing platforms | pkgdown | S3

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

The problem with future()+promise() | The solution: future_promise()

Motivation | Our source data | A tour of the app | The implementation | User interface | Server logic | Improving performance and scalability | Converting to async | Loading promises and mirai | The data reactive: mirai() all the things | The whales reactive: simple pipelines are simple | The whale_downloads reactive: reading from multiple promises | Promises: the Gathering | The total_downloaders value box: simple pipelines are for output, too | The biggest_whales plot: getting untidy | Revisiting the data reactive: progress support | Measuring scalability | Load testing with Shiny (coming soon) | Sync vs. async performance | Further optimizations | Summing up

Gathering | Nesting | Racing | Mapping | Reducing

How mirai works | Choosing a launch method | Caveats and limitations | Globals: Providing input to mirai code chunks | Package loading | Custom Data Types | Native resources | Mutation | Returning values

Adding prerequisites | Identifying slow operations | Converting a slow operation into a mirai | Shiny-specific caveats and limitations | Integrating promises with Shiny | Outputs | Render functions with side effects: renderPrint and renderPlot | Observers | Reactive expressions | The flush cycle

Async programming in R | Promises: the central abstraction of async programming | Accessing results with then | Promise chaining | Tee operator | Error handling | Catching errors with onRejected | Default onRejected behavior | Syntactic sugar for onRejected | Error tee | Cleaning up with finally

Development | Isolation | Library Paths | Testing | Submitting to CRAN

How future works | Choosing a launch method | Caveats and limitations | Globals: Providing input to future code chunks | Package loading | Native resources | Mutation | Returning values

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

Use any version of Chrome or chrome-headless-shell with chromote | Using a Chrome-based browser that you installed

Commands and Events | Automatic Events

Using JavaScript | Synchronous version | Asynchronous version | Using Chrome DevTools Protocol commands

Synchronous version | Asynchronous version

Why use async? | Async commands | Turning asynchronous code into synchronous code | Async events

Setting width and height of the viewport (window) | Taking a screenshot of a web page after interacting with it | Taking screenshots of web pages in parallel

Method 1: Manually interact with the page | Method 2: Capture and re-use cookies

Creating new tabs and managing the process | Commands and Events | The Chromote object model | Debugging | Resource cleanup and garbage collection

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

One connection per app | One connection per query | Pool: the best of both worlds

Introduction | Cloning an element | Removing an element | Full example

Creating an app | Source code

The central idea | An example using raw HTML | Use a tag list to achieve the same, but from R | Little harder but better example | The power of groups | Dragging and dropping shiny tabs

Using custom styles | Source code

Introduction | Rank list | Demo | Source code | Bucket list

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

Why Sass? | Sass Basics | Variables | Functions | Importing | Font imports | Mixins | More basics | Composable sass | Resolving relative imports | Attaching HTML dependencies | CSS output options | Output to a file | Compression | Source maps | Caching | In shiny | As a string | As a file | As a dynamic input | In rmarkdown

Using config for staging and prod on multiple servers | Using config for staging and prod on a single server | A utility function that might be helpful

A Simple Example | Learn More

Setting up RStudio Connect | Requirements | Access, Permissions, and Security | Configuring RStudio Connect as an Analytics Extension in Tableau | Tableau Server / Tableau Online | Tableau Desktop | Using Custom URLs for plumbertableau Extensions on RStudio Connect | Debugging plumbertableau Extensions on RStudio Connect

Getting Started | What can plumbertableau Extensions Do? | An Example with Loess Regression | The Anatomy of a plumbertableau Extension | Annotating Function Definitions for plumbertableau | Data Types | Tableau Extension Footer | Running and Testing Extensions Locally | Debugging Extensions | Deploying Extensions

Choosing a Tutorial's Language | Customizable UI elements: | Buttons | Text | Format of language Option in YAML Header: | Default Language | Customizing a Single Language | Customizing Multiple Languages | Store Customizations in a JSON File | Complete Translations

Overview | A repository with a single application | check-app.yaml | renv.lock, renv/activate.R, .Rprofile | Running the first build | A repository with multiple applications | Testing applications in a package | Frequently asked questions | How do I add a status badge to my project? | How do I use a DESCRIPTION file instead of {renv}? | Example workflows

What are promises good for? | What aren't promises good for?

TerminalExecute Scenario | Interative Terminal Scenario | Terminal Identifier | Terminal Session | Busy Terminal | Terminal States

Overview | Usage | Configurations | Configuration Files

Defaults and inheritance | Using R code inside the yaml file | Referencing previously assigned parameters | Limitations of using R expressions | A valid example | An invalid example

.rsconnect_profile | HTTP Proxy Environment Variable | Custom headers and cookies | Other custom options

Scheduled RMarkdown | runtime: shiny

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

Overview | Introducing tblcheck | Usage | Grading tables | Automated table checking | Finding problems | Checking class | Checking column names | Checking length | Checking column classes | Checking column values | Grading vectors | Automated vector checking | Custom Grading | Skipping tests | Additional Checks | Specific grading functions | Custom mistake handling

Alternative options for hosting learnr tutorials | Optimal settings for shinyapps.io | Optimizing for classroom settings | Reducing cost | Example use case | Context | Initial settings | Adjusting based on usage metrics | Troubleshooting beyond settings

Background | The reactive life cycle | A reactive graph | A session begins | Execution begins | Reading a reactive expression | Reading an input | Reactive expression completes | Observer completes | The next observer executes | Execution completes, outputs flushed | An input changes | Notifying dependents | Removing relationships | Re-execution | Hello Reactlog | Reactlog in detail | Status Bar | Progress Bar | Current step | Navigation Buttons | Search Bar | Dependency Graph | Reactive States | Highlighting and filtering | Zooming | Labeling nodes | Learn more

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

Overview | Checking Student Code | Custom Grading Logic | Compare with Solution Code | Writing Custom Logic | Exercise Objects | Grading Helper Functions | Feedback Messages

Overview | Multiple solutions, same result | Example | Providing different messages for different solutions | Multiple solutions, different results | Example | Working with all solution results

Code structure | Methods | ShinyDriver$click() | ShinyDriver$executeScript() | ShinyDriver$executeScriptAsync() | ShinyDriver$getAllValues() | ShinyDriver$getValue() | ShinyDriver$getUrl() | ShinyDriver$setInputs() | ShinyDriver$getWindowSize(), ShinyDriver$setWindowSize() | ShinyDriver$checkUniqueWidgetNames() | Snapshots | ShinyDriver$snapshotInit() | ShinyDriver$snapshot() | ShinyDriver$takeScreenshot() | ShinyDriver$snapshotDownload() | ShinyDriver$stop() | ShinyDriver$uploadFile() | ShinyDriver$waitFor() | ShinyDriver$waitForShiny() | ShinyDriver$waitForValue() | Elements / Widgets | ShinyDriver$findElement(), ShinyDriver$findElements(), ShinyDriver$findWidget() | ShinyDriver$getSource(), ShinyDriver$getTitle() | Testing setup | ShinyDriver$getRelativePathToApp(), ShinyDriver$getTestsDir() | ShinyDriver$getSnapshotDir() | ShinyDriver$expectUpdate() | Debugging | Other removed methods

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

Viewing Info on an Extension | Calling an Extension Endpoint in Tableau | Working with Tableau Data

Example: Grids grouped by owner

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

Introduction | Books | Online Resources | Coding D3 for r2d3

Overview | D3 Version | D3 Container | User Options | Sizing | Custom Sizing | Themes | Viewer

Overview | R2D3 wrapper function | Creating an htmlwidget | Multiple versions of D3 | d3-jetpack

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

Overview | Creating a Custom Model | Using a Custom Model

Creating WebSockets | Interaction with later | Adding handlers | Event environment | Removing handlers | Other notes

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

Overview | onRender Callback | onResize Callback

Default conversion | Data frames | Custom conversion | S3 conversion method

Overview | CSS Styles | d3-jetpack | JavaScript | External Libraries

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