AI Engineer World's Fair 2024
From model weights to API endpoint with TensorRT-LLM
Loading slides…
Read the talk
From model weights to an API endpoint with TensorRT-LLM
Build a GPU-specific inference engine, repeat the build with FP8, deploy it behind an API, and measure where throughput gains meet latency and serving constraints.
From a talk by Philip Kiely and Pankaj Gupta
Before you start: Basic familiarity with Python, model inference, and GPU memory will help; following the build requires access to a remote NVIDIA GPU.
What does it take to make inference fast?
How do you get from model weights to an endpoint that responds quickly, handles concurrent users, and makes efficient use of an expensive GPU? Philip Kiely and Pankaj Gupta’s workshop follows that entire path: select a supported model, build an engine manually, automate its configuration, benchmark the deployment, and address production serving. Kiely works in developer relations at Baseten; Gupta is its co-founder. The workshop uses Python, with live builds and debugging throughout. Its illustrated slides use Playground 2, Kiely’s preferred image-generation model.
The performance problem has several dimensions. A user wants a short time to first token, followed by a fast stream of generated tokens. An operator also wants high aggregate throughput: enough useful work from each GPU to justify its cost. Improving one number does not automatically improve all the others.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The graph executor and the LLM runtime
TensorRT is NVIDIA’s SDK for high-performance inference, with C++ and Python interfaces. Its starting point is a computation graph: operations connected by tensors flowing between them. Express a model in that representation, and TensorRT can recognize patterns, optimize the graph, and execute it.
Graph optimization alone cannot discover every specialized algorithm. TensorRT therefore provides a plugin mechanism: a plugin recognizes or implements an operation and supplies a better execution path. TensorRT-LLM builds on this mechanism with optimized CUDA kernels for transformer operations, including attention implementations such as FlashAttention.
TensorRT-LLM also adds the machinery needed to serve multiple generation requests, particularly in-flight batching, rather than treating inference as isolated graph executions. Gupta describes a 10–20× improvement from in-flight batching, without specifying the workload or measured metric. The architectural distinction matters more than that informal multiplier: TensorRT executes the graph; TensorRT-LLM supplies LLM-specific execution, batching, and model-conversion support.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Build for the workload and the GPU
An engine needs more information than the model name. Its optimization profile depends on batch size and input and output sequence lengths. Summarizing a book produces a different workload from a short bank-chat greeting. TensorRT-LLM has kernels specialized for different matrix sizes, so those shape constraints help it select efficient execution paths. That specialization also explains why compiling the library itself can take hours.
Kiely compares optimization to a made-to-measure suit. An off-the-shelf size can work, but a close fit requires measurements. Here those measurements include expected sequence lengths, concurrent requests, and the production GPU. Baseten was already using TensorRT-LLM in production, with A10, A100, and H100 support; Volta support was described as experimental. The trade-offs included a steep learning curve and underlying components whose source was not fully available.
Treat the GPU configuration as part of the build target. In the workflow demonstrated, an A10 build runs on an A10, an H100 build runs on an H100, and moving to an H100 MIG partition calls for another build. Large artifacts also make cold starts harder, while combining recent optimization techniques introduces integration rough edges. Gupta qualifies the portability rule: compatibility modes exist, but Baseten avoids them because they give up some target-specific optimization.
For Mistral 7B, Kiely reports 216 perceived tokens per second and 180 ms time to first token on Artificial Analysis, using TensorRT-LLM plus additional optimizations. The 180 ms includes the network round trip. Gupta reports less than 50 ms on the GPU for that result. Kiely uses a roughly 200 ms human-reaction-time analogy to explain why such a response feels immediate; the recording does not supply the benchmark’s full hardware and sequence configuration.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Architecture, hardware, and precision determine the options
At the workshop, Kiely describes approximately 50 documented foundation models, plus fine-tunes of supported architectures. Support extends beyond text generation to vision models and Whisper, an audio-transcription model. Whisper fits because it has an encoder-decoder transformer architecture and an autoregressive decoding stage with familiar inference bottlenecks. Gupta connects it to Attention Is All You Need: audio-to-text can be understood as a translation task. TensorRT is the general foundation; TensorRT-LLM provides the convenient architecture-specific paths.
Hardware support spans several generations, including H100, L4, RTX 4090, Ampere and Turing GPUs, with qualified support for V100. Newer hardware brings more than additional FLOPS or memory bandwidth: optimized kernels can exploit architectural features. Kiely highlights H100 MIG partitions for models around 7B–8B parameters that can benefit from the architecture without requiring a full H100’s memory. Blackwell support is still a forecast at this point in the recording.
The workshop illustrates this hardware effect with SDXL, using TensorRT rather than TensorRT-LLM.
| GPU | Reported SDXL throughput increase with TensorRT |
|---|---|
| A10G | Approximately 25–30% |
| H100 | Approximately 70% |
Each percentage compares TensorRT with a non-TensorRT baseline on the same GPU; it is not the increase obtained by replacing an A10G with an H100.
Precision is another hardware-dependent choice. H100 supports FP8 arithmetic, while A100 does not; L4 also supports FP8. Gupta describes post-training FP8 quantization taking roughly five minutes and delivering about 40% better performance in most scenarios his team tested, without identifying a precise performance metric. He says their perplexity checks found close results, but stresses that quantization requires an accuracy evaluation. The stated inference baseline is FP16, or half precision; FP32 is full precision. INT8 and FP8 can reduce memory requirements and enable faster execution on suitable hardware. FP4, like Blackwell, is discussed as a future possibility.
Beyond precision, the optimization menu includes LoRA swapping, speculative decoding, in-flight batching, and paged attention. Medusa adds trained decoding heads to propose multiple tokens per step. Kiely illustrates it with roughly four tokens per forward pass, particularly useful when memory bandwidth limits generation; that illustration should not be read as a fixed number of accepted tokens on every step.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose the optimization effort before distributing the model
An audience question puts TensorRT-LLM alongside vLLM. Gupta says TensorRT-LLM performed better in most of Baseten’s comparisons, pointing to early optimization for new NVIDIA hardware and the execution stack from CUDA kernels through the C++ batching engine to Triton serving. But feature availability can favor another framework: Baseten used vLLM for LoRA swapping before that feature was available in TensorRT-LLM, and continued to value its flexibility.
The learning curve is part of the calculation. Gupta suggests that one or two A10G or T4 GPUs may not justify substantial optimization work, while A100 and H100 deployments deserve a closer look. His economic example is a business spending hundreds of thousands of dollars annually: with a 20% margin, an illustrative 20–50% efficiency improvement could materially change the business. These are decision inputs, not a measured break-even threshold.
For a short development loop, the workshop uses TinyLlama 1.1B on RTX 4090 and A10G hardware. The manual exercise is deliberately small: procure a GPU, install dependencies, configure and build an engine, then test it. The RTX 4090 also enables the FP8 exercise. Sequence shapes, batch size, and tensor parallelism are the main configuration dimensions introduced before the build.
Tensor parallelism divides matrix operations across GPUs and combines their results. This can reduce execution time within a layer, at the cost of communication. The alternatives divide different parts of the work:
| Approach | What is divided | Main implication |
|---|---|---|
| Tensor parallelism | Matrices within operations | Parallel computation plus communication |
| Pipeline parallelism | Groups of layers | A request still traverses successive stages |
| Expert parallelism | Mixture-of-experts components | Applies to models with separate experts |
Gupta had rarely encountered pipeline parallelism in his inference work because it does not provide the same per-request latency benefit. The workshop’s Llama model has no mixture of experts. If a model fits on a larger single GPU, that can offer better throughput; Llama 70B is his example of needing distribution under the assumed memory and precision configuration.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Provision the remote build environment
Start with the workshop repository, which contains the manual build, automated deployment, and benchmarking exercises. The presenters ask participants to fork and clone it into their usual Python development environment. The GPUs are remote: a laptop is enough to follow along.
The manual-build instructions include a RunPod setup walkthrough. Participants need an account, credits, and an SSH key. The presenters estimate less than $5 of exercise usage, against a $10 minimum credit purchase at the time. They state that they are not affiliated with RunPod and offer workshop participants reimbursement and individual setup help.
Provisioning produces the first live failure: several attendees’ credit cards are declined on conference Wi-Fi. A payment-provider or shared-IP block is suggested, but not established. Participants try phone hotspots while Gupta continues the demonstration from his existing account.
The GPU setup is concrete:
- Select an RTX 4090 instance.
- Set the container disk, rather than the volume disk, to 200 GB for dependencies and artifacts.
- Use the specified PyTorch/CUDA template.
- Connect with SSH and run
nvidia-smibefore installing the inference stack.
Gupta prefers on-demand capacity for demo continuity, while discussing Spot as an interruptible alternative. The GPU check shows roughly 24 GB of memory, with about 1 MB initially occupied. Large-model artifacts can be much larger than this exercise’s engine, so storage capacity needs its own check.
Installation first prepares the Python and OpenMPI dependencies, then installs a pinned TensorRT-LLM package from NVIDIA’s package index. The companion instructions specify Python 3.10, TensorRT-LLM 0.11.0.dev2024061800, and TensorRT-LLM repository commit 2a115dae84f13daaa54727534daa837c534eceb4; those are the historical exercise’s pins, not a prescription to combine old examples with current packages. A question about mpi4py reinforces the need to install the MPI prerequisites. By this point, attendees confirm that switching to hotspots has allowed account setup to proceed.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Download, convert, build, and generate
NVIDIA’s NGC container images offer an alternative to assembling the dependencies manually. In the live path, Gupta verifies the installed TensorRT-LLM version, clones its repository, and opens the Llama example. These two checks can be run from Python before proceeding:
python
import subprocess
import tensorrt_llm
subprocess.run(["nvidia-smi"], check=True)
print("TensorRT-LLM:", tensorrt_llm.__version__)
The model-specific examples supply the conversion and run scripts used next.
The download helper is hf_transfer, enabled in the companion instructions through HF_HUB_ENABLE_HF_TRANSFER. It accelerates transfers by downloading slices in parallel. Gupta observes approximately 1 GB/s during the remote model download; the transfer runs on the GPU host, not across the laptop’s conference Wi-Fi. The companion model identifier is TinyLlama/TinyLlama-1.1B-Chat-v1.0.
The build now has four distinct stages:
- Download weights from Hugging Face.
- Convert the checkpoint into TensorRT-LLM’s expected representation, including any required precision or tensor-parallel layout.
- Build the engine with
trtllm-build, initially using mostly default settings. - Load and run the serialized engine with the example runner.
Gupta reports about three seconds for the TinyLlama checkpoint conversion. The first engine is approximately 2 GB, with the weights bundled inside and relatively little additional storage overhead. He likens it to a shared library: a binary artifact that TensorRT loads with the TensorRT-LLM plugins available.
The run script provides the first end-to-end check. Given the prompt “Born in northeast France, Sorrell trained as a…”, the model continues with a passage about training as a painter in Paris before moving to London in 1929. At this point, weights have become an executable inference artifact and produced text; the serving endpoint comes later.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What conversion, building, and stopping each control
Checkpoint conversion has three possible responsibilities. It normalizes tensors into the structure the runtime expects; it may quantize weights; and it may divide those weights among tensor-parallel ranks. These responsibilities are related but not identical. Some quantization paths use a separate quantize.py script and NVIDIA’s then-named AMMO library. Gupta is tentative about the exact placement of AWQ and SmoothQuant, so the practical rule is to follow the conversion path for the chosen model and quantization recipe.
Another question distinguishes engine shape limits from runtime stopping conditions. An attendee sees output cut off at a limit of 50, but little difference between limits of 250 and 500. Build-time output-length settings guide the engine’s optimization and supported shapes. Runtime max_tokens caps generation; it does not tell the model to plan an answer of that length.
Generation can stop before the cap when the model emits an end-of-sequence token. For benchmarking, the runtime can instead ignore EOS and generate the requested number of tokens. That makes comparisons across GPUs or configurations easier because an early-stopping answer does not silently reduce the amount of decoding work.
Building the engine is more than repackaging weights. TensorRT-LLM creates a TensorRT network, populates it with the architecture and weights, and uses generated sample inputs during optimization. The resulting engine exists in memory before it is serialized. The trtllm-build help output exposes further controls, including maximum beam width, logits output, fused MLP, context chunking, and LoRA support.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Repeat the build with FP8
The second build uses the RTX 4090’s FP8 support. Gupta runs quantize.py through AMMO and selects FP8 for both the quantization format and the KV-cache dtype. These are separate decisions: weights are persistent model parameters, while the KV cache stores attention keys and values produced as requests run.
Low-precision tensor-core operations can provide more arithmetic throughput, which matters especially when prefill is compute-bound. Decoding is often constrained by memory bandwidth, so reducing data movement also helps. The recording connects those gains to quantizing both weights and cache, but stored cache precision does not establish the precision of every matrix operand: weights, activations, and KV-cache storage have distinct settings, and mixed-precision recipes exist. Current NVIDIA quantization documentation makes those distinctions explicit; it also covers Model Optimizer and the Blackwell/FP4 support that was still prospective in this workshop. The historical AMMO engine-build workflow remains the one demonstrated here.
The quality question is different for weights and cached attention state. Gupta describes weights as comparatively easy to quantize, while Baseten had seen quality degradation with INT8 KV-cache quantization, including attempts involving SmoothQuant. FP8 worked substantially better in their experience.
Kiely explains the numerical intuition with E4M3: one sign bit, four exponent bits, and three mantissa bits. Both INT8 and FP8 have 256 possible bit patterns, but they distribute representable values differently. Floating-point spacing is nonuniform, providing finer absolute resolution near small magnitudes and wider spacing at larger magnitudes. This changes the trade-off between range and precision that matters for sensitive cached values.
Quantization includes calibration. The script runs a dataset through the model to estimate layer-specific ranges and scaling. That dataset can be changed to resemble production inputs; Gupta finds FP8 forgiving, but not perfect. After calibration, the workflow builds another engine with the corresponding FP8 kernels. Timing caches and optimization profiles offer further tuning beyond this first pass.
The FP8 engine is approximately 1.2 GB, compared with approximately 2 GB for the first engine. Running the same Sorrell prompt produces similar text. This checks that the quantized path runs and retains plausible behavior on that example; it does not replace an accuracy evaluation over the intended workload.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn the build into a deployed service
Truss provides the automation boundary. It packages an environment configuration and Python code for model serving, including model-data access and secure tokens. Its general interface accommodates TensorRT-LLM, vLLM, Triton, Transformers, Diffusers, and XGBoost, with a live-reload development loop. For this workshop’s TensorRT-LLM path, however, no custom model-server Python is needed: the build is described in YAML.
The abstraction still needs the measurements from the manual build: model, GPU, input and output lengths, batch size, quantization, and optional optimizations. It then takes the extra step of deploying the engine behind an API endpoint. Automation removes repeated setup work without removing the workload choices.
Participants create Baseten accounts and API keys, but the automated path encounters its own live failure. Kiely explains that the TensorRT-LLM build system had just shipped as an internal beta and this is its first external use. The team escalates attendee errors and continues the demonstration using a locally cached image. The subsequent logs and endpoint walkthrough therefore should not be read as evidence that every fresh attendee deployment succeeded.
The demonstrated deployment configuration uses input and output sequence limits of 2,000 tokens each and a maximum batch size of 64. It selects INT8 because this deployment runs on an A10, whose Ampere architecture lacks FP8 support. Build and deployment logs expose the process, and the Call Model interface supplies an endpoint test. Baseten’s listed GPU options are data-center devices: T4, A10, A100, H100, H100 MIG, and L4.
For a model needing custom checkpoint conversion, Gupta points back to the open-source conversion scripts. Model authors often provide them; otherwise, a developer familiar with Hugging Face Transformers can inspect how weights are read and transformed into the required structure. Once deployment completes, an HTTP call tests the served model—but a successful call alone says little about production capacity.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Measure the operating point, not just a fast response
Benchmark the deployed workload before choosing its operating point. Streaming chat emphasizes time to first token and per-request token rate. Kiely offers approximately 30–50 tokens per second as a reading-speed heuristic, dependent on the tokenizer, content, and reader. Code can need a higher token rate for equally smooth output because its tokenization differs from prose.
A deployment can trade some per-request speed for better aggregate throughput. Kiely illustrates accepting 100 instead of 120 tokens per second per request if the larger batch lowers cost per million tokens. Measure both the rate an individual user receives and the total rate the GPU produces, and examine p50, p90, p95, and p99 behavior across batch sizes.
Those curves need not be linear. In Kiely’s historical Mistral example, TTFT barely changes between batch sizes 32 and 64, then increases sharply between 64 and 128. He attributes the cliff to compute saturation during prefill, using a simplified picture of computation slots colliding as occupancy rises. The useful deployment lesson is to measure where saturation changes latency rather than extrapolate from a smaller batch.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Load the streaming endpoint
The workshop includes a simplified Python async benchmark, separate from Baseten’s internal benchmark suite. It sends concurrent requests to an endpoint and accepts input length, output length, concurrency, and repeated-run count. A Makefile target wraps the invocation. Supply the deployed model URL and export the API key; the Call Model dialog provides request examples, with a Streaming option for receiving output as it is produced.
The API key stays off screen, and an exposed key can be revoked. During this pause, Baseten is described as SOC 2 Type II certified and HIPAA compliant. Gupta then starts the measurement with concurrency 32 and 1,000-token inputs and outputs, discarding a warm-up run before interpreting the results.
For TinyLlama on A10G, Gupta reports approximately 5,000 aggregate tokens per second at concurrency 32 with 1,000-token inputs and outputs. The small model is central to interpreting that throughput. He separately mentions up to approximately 11,000 tokens per second for Llama 8B on larger H100 hardware, without supplying a comparable workload configuration.
Next he reduces concurrency to one while retaining the same input and output lengths. After a transient error and retry, Gupta reports approximately 180 ms TTFT from the conference laptop over Wi-Fi to a model deployed in US Central. The presenters attribute most of that delay to networking rather than model execution.
An audience member asks about a warning mentioning PyTorch, TensorFlow, and Flax. It comes from the local benchmark environment, not the remote model server: this client makes HTTP/RPC calls and does not need to run a model locally. Gupta also recounts a separate case in which a k6 client became the bottleneck while Python async kept up with the H100 streaming load. The load generator itself must have enough capacity to measure the server.
At concurrency 64, the same TinyLlama/A10G test reports approximately 7,000 aggregate tokens per second in both measured runs, up from approximately 5,000 at concurrency 32. More concurrent work raises total throughput, but slows token delivery to each request and consumes more GPU memory for KV cache. The useful operating point balances aggregate throughput, per-request responsiveness, and memory capacity.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Separate engine limits from serving bottlenecks
The deployment was built with maximum batch size 64. Sending more requests does not increase its active batch beyond that cap; excess requests wait. Raising the engine limit to 128 requires changing the YAML and rebuilding through deployment.
Check the TensorRT-LLM batch manager’s active request count to see how much work actually reaches the GPU. A serving platform’s concurrency or scaling settings can restrict traffic before it reaches the engine, leaving the GPU underloaded even when the benchmark client sends enough requests. Engine capacity and platform admission limits are separate controls.
The batch manager also exposes KV-cache allocation. In the displayed example, Gupta reports 832 KV-cache blocks in use and approximately 4,500 empty. That suggests the configured cache has substantial headroom for this workload, providing a concrete signal for tuning rather than guessing from total GPU memory alone.
Native benchmarks answer different questions from the HTTP client:
| Benchmark | What it measures |
|---|---|
| Single-batch tool | Raw batch throughput without in-flight serving |
| GPT manager benchmark | Execution with the in-flight batching machinery |
| Workshop HTTP client | Streaming behavior through the deployed endpoint |
At workshop time, Gupta says the native tools require a source build rather than arriving with the Python package. He reports about 1.5 hours to compile TensorRT-LLM using 96 CPUs, explaining why the workshop uses the simpler endpoint script.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Scale replicas without losing the engine’s assumptions
Triton Inference Server is the serving route introduced for running requests against the engine. Baseten is also developing its own server layer with C++ tokenization and detokenization. Either route must respect the engine’s software versions, GPU target, batch limits, and sequence shapes. Optimizing a single GPU is vertical scaling; adding replicas introduces another set of responsibilities.
Horizontal scaling must react to traffic, find reliable GPU nodes, route requests, preserve useful batching, and manage cold starts. TensorRT-LLM adds large images and target-specific engine artifacts: replacement replicas need compatible hardware, and transferring the artifacts can dominate startup. Baseten presents managed autoscaling, fast cold starts, scale to zero, and pre-optimized models as its infrastructure offering, alongside support for vLLM, TGI, and ordinary model deployments.
The closing questions make the autoscaling mechanism concrete. Gupta says Baseten uses a fork of Knative adapted for long-lived, streaming ML requests. One motivation is changing settings dynamically instead of creating a new revision and temporarily requiring extra deployment capacity. He reports that many Baseten settings apply within approximately one second.
The control flow follows configured pod capacity:
- Requests arrive at existing pods.
- As load approaches the configured capacity, new pods start and traffic spreads across them.
- As demand falls, pods are removed and GPUs are released, potentially down to zero.
- A request arriving at zero replicas waits in a queue while the model starts, then proceeds to inference.
The queue makes cold-start time part of the request’s latency budget.
Gupta states cold-start targets of under 10 seconds for 10 GB models and under one minute for 50 GB models. These are operational targets, not measured results from this workshop. Scale to zero is useful only if the model can start before the waiting request times out; startup performance therefore determines whether the capacity policy is viable.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What remains yours to operate
An audience member asks whether running Llama 8B with TensorRT directly would differ from running it on Baseten. The underlying runtime can be the same: Baseten runs TensorRT-LLM and automates reaching a suitable configuration. With equivalent optimization, Gupta says self-managed hardware can reach the same underlying performance. The managed service adds setup, scaling, and operational infrastructure. Gupta also argues that fleet purchasing economics avoid a higher customer price, but supplies no pricing comparison.
The open-source boundary needs one final clarification. Kiely initially describes Truss as packaging only, but Gupta explains that it can build a Docker image locally and that the image includes single-model serving. That container can run elsewhere, including on a manually provisioned GPU host. Fleet orchestration, autoscaling, and the managed development loop remain separate from that single-container capability.
In the Triton-backed route, the serving stack is FastAPI → Triton → TensorRT-LLM → engine. Gupta also describes a Baseten-specific TensorRT-LLM server layer that is not open source at the time. Across multiple cloud providers, the platform selects appropriate hardware, builds the engine for it, and deploys it; he says the entire platform stack can also run in a self-hosted cluster. The final deployment choice is therefore about which serving and fleet-management responsibilities to own around the optimized engine.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Companion materials for manual engine building, automated Truss deployment, and endpoint benchmarking.
Historical workshop instructions with pinned dependencies, RunPod setup, checkpoint conversion, and FP16/FP8 builds.
Baseten's open-source framework for packaging and serving machine learning models.
The original Transformer paper referenced during the encoder-decoder discussion.
Research on accelerating language-model inference with additional decoding heads.
Further reading
Explains latency, throughput, batch sizes, sequence lengths, connection reuse, and tokenizer choices using Mistral 7B measurements.
Describes component-level SDXL optimization and same-hardware latency and throughput comparisons across NVIDIA GPUs.
Updates since the talk
Later TensorRT-LLM guidance on FP8 engines, optional KV-cache quantization, performance tuning, and quality checks.
Current quantization recipes, Model Optimizer workflows, and model and hardware support tables.
Full transcript
Loading transcript…