Tutorials
+Model Zoo
-
-
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
Python API Documentation
-
diff --git a/docs/_cpp_api/classtorch__tensorrt_1_1Device_1_1DeviceType.html b/docs/_cpp_api/classtorch__tensorrt_1_1Device_1_1DeviceType.html
index 6df355a23e..dfb210b55c 100644
--- a/docs/_cpp_api/classtorch__tensorrt_1_1Device_1_1DeviceType.html
+++ b/docs/_cpp_api/classtorch__tensorrt_1_1Device_1_1DeviceType.html
@@ -10,7 +10,7 @@
-
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
- Deploy Quantized Models using Torch-TensorRT
- Engine Caching
- Refitting Torch-TensorRT Programs with New Weights +
- Serving a Torch-TensorRT model with Triton +
- Torch Export with Cudagraphs +
- Overloading Torch-TensorRT Converters with Custom Converters +
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT +
- Mutable Torch TensorRT Module
- Serving a Torch-TensorRT model with Triton -
- Example notebooks -
- Compiling ResNet using the Torch-TensorRT torch.compile Backend -
- Compiling a Transformer using torch.compile and TensorRT -
- Torch Compile Stable Diffusion -
- Torch Export with Cudagraphs -
- Overloading Torch-TensorRT Converters with Custom Converters -
- Using Custom Kernels within TensorRT Engines with Torch-TensorRT -
- Mutable Torch TensorRT Module -
- Compiling GPT2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Compiling Llama2 using the Torch-TensorRT with dynamo backend -
- The output sentences should look like -
- Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and +
- Compiling ResNet with dynamic shapes using the torch.compile backend +
- Compiling BERT using the torch.compile backend +
- Compiling Stable Diffusion model using the torch.compile backend +
- Compiling GPT2 using the dynamo backend +
- Compiling Llama2 using the dynamo backend +
- Legacy notebooks
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/classtorch__tensorrt_1_1TensorFormat.html b/docs/_cpp_api/classtorch__tensorrt_1_1TensorFormat.html
index 1e742c8858..ef47addfaa 100644
--- a/docs/_cpp_api/classtorch__tensorrt_1_1TensorFormat.html
+++ b/docs/_cpp_api/classtorch__tensorrt_1_1TensorFormat.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8CacheCalibrator.html b/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8CacheCalibrator.html
index ed1ea18288..9b6b3dbb7f 100644
--- a/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8CacheCalibrator.html
+++ b/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8CacheCalibrator.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8Calibrator.html b/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8Calibrator.html
index cefa00b7f2..54ad25a97c 100644
--- a/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8Calibrator.html
+++ b/docs/_cpp_api/classtorch__tensorrt_1_1ptq_1_1Int8Calibrator.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1a18d295a837ac71add5578860b55e5502.html b/docs/_cpp_api/define_macros_8h_1a18d295a837ac71add5578860b55e5502.html
index 043a615aec..80ab3374ad 100644
--- a/docs/_cpp_api/define_macros_8h_1a18d295a837ac71add5578860b55e5502.html
+++ b/docs/_cpp_api/define_macros_8h_1a18d295a837ac71add5578860b55e5502.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1a282fd3c0b1c3a215148ae372070e1268.html b/docs/_cpp_api/define_macros_8h_1a282fd3c0b1c3a215148ae372070e1268.html
index 8aab792e3c..6099cd4238 100644
--- a/docs/_cpp_api/define_macros_8h_1a282fd3c0b1c3a215148ae372070e1268.html
+++ b/docs/_cpp_api/define_macros_8h_1a282fd3c0b1c3a215148ae372070e1268.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1a31398a6d4d27e28817afb0f0139e909e.html b/docs/_cpp_api/define_macros_8h_1a31398a6d4d27e28817afb0f0139e909e.html
index 957d9293a7..2439b9d7c4 100644
--- a/docs/_cpp_api/define_macros_8h_1a31398a6d4d27e28817afb0f0139e909e.html
+++ b/docs/_cpp_api/define_macros_8h_1a31398a6d4d27e28817afb0f0139e909e.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1a35703561b26b1a9d2738ad7d58b27827.html b/docs/_cpp_api/define_macros_8h_1a35703561b26b1a9d2738ad7d58b27827.html
index 9804cb2851..d08e9b3724 100644
--- a/docs/_cpp_api/define_macros_8h_1a35703561b26b1a9d2738ad7d58b27827.html
+++ b/docs/_cpp_api/define_macros_8h_1a35703561b26b1a9d2738ad7d58b27827.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1abd1465eb38256d3f22cc1426b23d516b.html b/docs/_cpp_api/define_macros_8h_1abd1465eb38256d3f22cc1426b23d516b.html
index e0080e7724..3e9ba6bc17 100644
--- a/docs/_cpp_api/define_macros_8h_1abd1465eb38256d3f22cc1426b23d516b.html
+++ b/docs/_cpp_api/define_macros_8h_1abd1465eb38256d3f22cc1426b23d516b.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1abe87b341f562fd1cf40b7672e4d759da.html b/docs/_cpp_api/define_macros_8h_1abe87b341f562fd1cf40b7672e4d759da.html
index 4c1ba1e459..129726fa1a 100644
--- a/docs/_cpp_api/define_macros_8h_1abe87b341f562fd1cf40b7672e4d759da.html
+++ b/docs/_cpp_api/define_macros_8h_1abe87b341f562fd1cf40b7672e4d759da.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1ad19939408f7be171a74a89928b36eb59.html b/docs/_cpp_api/define_macros_8h_1ad19939408f7be171a74a89928b36eb59.html
index b5d8bce2cc..0686c37902 100644
--- a/docs/_cpp_api/define_macros_8h_1ad19939408f7be171a74a89928b36eb59.html
+++ b/docs/_cpp_api/define_macros_8h_1ad19939408f7be171a74a89928b36eb59.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/define_macros_8h_1adad592a7b1b7eed529cdf6acd584c883.html b/docs/_cpp_api/define_macros_8h_1adad592a7b1b7eed529cdf6acd584c883.html
index f62866c87f..e180a05377 100644
--- a/docs/_cpp_api/define_macros_8h_1adad592a7b1b7eed529cdf6acd584c883.html
+++ b/docs/_cpp_api/define_macros_8h_1adad592a7b1b7eed529cdf6acd584c883.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/dir_cpp.html b/docs/_cpp_api/dir_cpp.html
index 1dc9f93a3d..64f9020907 100644
--- a/docs/_cpp_api/dir_cpp.html
+++ b/docs/_cpp_api/dir_cpp.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/dir_cpp_include.html b/docs/_cpp_api/dir_cpp_include.html
index 8d487abd55..6f40b740a9 100644
--- a/docs/_cpp_api/dir_cpp_include.html
+++ b/docs/_cpp_api/dir_cpp_include.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/dir_cpp_include_torch_tensorrt.html b/docs/_cpp_api/dir_cpp_include_torch_tensorrt.html
index a41562c80b..3836287950 100644
--- a/docs/_cpp_api/dir_cpp_include_torch_tensorrt.html
+++ b/docs/_cpp_api/dir_cpp_include_torch_tensorrt.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/enum_namespacetorch__tensorrt_1_1logging_1a130f65408ad8cbaee060f05e8db69558.html b/docs/_cpp_api/enum_namespacetorch__tensorrt_1_1logging_1a130f65408ad8cbaee060f05e8db69558.html
index 9e0bef85d4..be0a310fbf 100644
--- a/docs/_cpp_api/enum_namespacetorch__tensorrt_1_1logging_1a130f65408ad8cbaee060f05e8db69558.html
+++ b/docs/_cpp_api/enum_namespacetorch__tensorrt_1_1logging_1a130f65408ad8cbaee060f05e8db69558.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/enum_namespacetorch__tensorrt_1a3fbe5d72e4fc624dbd038853079620eb.html b/docs/_cpp_api/enum_namespacetorch__tensorrt_1a3fbe5d72e4fc624dbd038853079620eb.html
index 82688bbf99..ed2986beaf 100644
--- a/docs/_cpp_api/enum_namespacetorch__tensorrt_1a3fbe5d72e4fc624dbd038853079620eb.html
+++ b/docs/_cpp_api/enum_namespacetorch__tensorrt_1a3fbe5d72e4fc624dbd038853079620eb.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/file_cpp_include_torch_tensorrt_logging.h.html b/docs/_cpp_api/file_cpp_include_torch_tensorrt_logging.h.html
index f9f20e6923..11e427e13c 100644
--- a/docs/_cpp_api/file_cpp_include_torch_tensorrt_logging.h.html
+++ b/docs/_cpp_api/file_cpp_include_torch_tensorrt_logging.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/file_cpp_include_torch_tensorrt_macros.h.html b/docs/_cpp_api/file_cpp_include_torch_tensorrt_macros.h.html
index aff61c357a..b90f4c39f4 100644
--- a/docs/_cpp_api/file_cpp_include_torch_tensorrt_macros.h.html
+++ b/docs/_cpp_api/file_cpp_include_torch_tensorrt_macros.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/file_cpp_include_torch_tensorrt_ptq.h.html b/docs/_cpp_api/file_cpp_include_torch_tensorrt_ptq.h.html
index 4e3e32ac07..cf90cad5c2 100644
--- a/docs/_cpp_api/file_cpp_include_torch_tensorrt_ptq.h.html
+++ b/docs/_cpp_api/file_cpp_include_torch_tensorrt_ptq.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/file_cpp_include_torch_tensorrt_torch_tensorrt.h.html b/docs/_cpp_api/file_cpp_include_torch_tensorrt_torch_tensorrt.h.html
index 55693d4236..a2e9b6c3f2 100644
--- a/docs/_cpp_api/file_cpp_include_torch_tensorrt_torch_tensorrt.h.html
+++ b/docs/_cpp_api/file_cpp_include_torch_tensorrt_torch_tensorrt.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0593f776f469c20469e2f729fc7861a3.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0593f776f469c20469e2f729fc7861a3.html
index cdbc971e1b..47d9382559 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0593f776f469c20469e2f729fc7861a3.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0593f776f469c20469e2f729fc7861a3.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0c012cb374addd90eb1f42eaec570650.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0c012cb374addd90eb1f42eaec570650.html
index e7ecd1ead6..d718ab87c7 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0c012cb374addd90eb1f42eaec570650.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a0c012cb374addd90eb1f42eaec570650.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a56e110feaaba2c3fd44bd201fd21a76a.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a56e110feaaba2c3fd44bd201fd21a76a.html
index b3e92c9c63..76f15d606c 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a56e110feaaba2c3fd44bd201fd21a76a.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a56e110feaaba2c3fd44bd201fd21a76a.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a7cb50492421ea9de4e3db895819df6f2.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a7cb50492421ea9de4e3db895819df6f2.html
index 4fceca8387..3c22247ad6 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a7cb50492421ea9de4e3db895819df6f2.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1a7cb50492421ea9de4e3db895819df6f2.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ac46ac0901cb97e3ae6e93b45f24e90b8.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ac46ac0901cb97e3ae6e93b45f24e90b8.html
index 4588bab5ac..97c5a87486 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ac46ac0901cb97e3ae6e93b45f24e90b8.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ac46ac0901cb97e3ae6e93b45f24e90b8.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ad2efd47b6c3689e58ccc595680579ae5.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ad2efd47b6c3689e58ccc595680579ae5.html
index 03a14fd43e..f5cc717713 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ad2efd47b6c3689e58ccc595680579ae5.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1ad2efd47b6c3689e58ccc595680579ae5.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1af8f3443813315af7901903d25dd495cc.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1af8f3443813315af7901903d25dd495cc.html
index 0f11a63959..5c9d4b1264 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1af8f3443813315af7901903d25dd495cc.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1logging_1af8f3443813315af7901903d25dd495cc.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a226e3c83379d1012cde8578c1c86b16c.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a226e3c83379d1012cde8578c1c86b16c.html
index 358267fa7b..45ef6c88ce 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a226e3c83379d1012cde8578c1c86b16c.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a226e3c83379d1012cde8578c1c86b16c.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a6186e305f47c1d94b6130ef6c7f7e178.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a6186e305f47c1d94b6130ef6c7f7e178.html
index d611774b68..8a21fee2ff 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a6186e305f47c1d94b6130ef6c7f7e178.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1ptq_1a6186e305f47c1d94b6130ef6c7f7e178.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a5b405fd3bf3c8fc2e2a54cbbab979797.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a5b405fd3bf3c8fc2e2a54cbbab979797.html
index 72b0289721..a596a9d015 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a5b405fd3bf3c8fc2e2a54cbbab979797.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a5b405fd3bf3c8fc2e2a54cbbab979797.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a6e19490a08fb1553c9dd347a5ae79db9.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a6e19490a08fb1553c9dd347a5ae79db9.html
index e78ec14057..af21e2fd5a 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a6e19490a08fb1553c9dd347a5ae79db9.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a6e19490a08fb1553c9dd347a5ae79db9.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a81f9783517335dda877d8cfcf38987c9.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a81f9783517335dda877d8cfcf38987c9.html
index 75988e7b3f..d544a0590d 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a81f9783517335dda877d8cfcf38987c9.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1a81f9783517335dda877d8cfcf38987c9.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1ae8d56472106eeef37fbe51ff7f40c9b2.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1ae8d56472106eeef37fbe51ff7f40c9b2.html
index c49e4fe18a..df3e447ccd 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1ae8d56472106eeef37fbe51ff7f40c9b2.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1_1torchscript_1ae8d56472106eeef37fbe51ff7f40c9b2.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1ac4ab8313ae72c2c899ea31548b528528.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1ac4ab8313ae72c2c899ea31548b528528.html
index 66b1fbc1f9..ae9a8d586e 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1ac4ab8313ae72c2c899ea31548b528528.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1ac4ab8313ae72c2c899ea31548b528528.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1ad1acd06eaeaffbbcf6e7ebf426891384.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1ad1acd06eaeaffbbcf6e7ebf426891384.html
index ed7a0ff356..1d986ace58 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1ad1acd06eaeaffbbcf6e7ebf426891384.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1ad1acd06eaeaffbbcf6e7ebf426891384.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/function_namespacetorch__tensorrt_1ad6a4ee8ca6c8f6e5519eb1128ec7f4a1.html b/docs/_cpp_api/function_namespacetorch__tensorrt_1ad6a4ee8ca6c8f6e5519eb1128ec7f4a1.html
index 4a9cc3948b..c39bedc9cc 100644
--- a/docs/_cpp_api/function_namespacetorch__tensorrt_1ad6a4ee8ca6c8f6e5519eb1128ec7f4a1.html
+++ b/docs/_cpp_api/function_namespacetorch__tensorrt_1ad6a4ee8ca6c8f6e5519eb1128ec7f4a1.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/namespace_torch_tensorrt.html b/docs/_cpp_api/namespace_torch_tensorrt.html
index 03c97d77d4..1d5d7b82f4 100644
--- a/docs/_cpp_api/namespace_torch_tensorrt.html
+++ b/docs/_cpp_api/namespace_torch_tensorrt.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/namespace_torch_tensorrt__logging.html b/docs/_cpp_api/namespace_torch_tensorrt__logging.html
index 2fc654fbec..4ee232e1e7 100644
--- a/docs/_cpp_api/namespace_torch_tensorrt__logging.html
+++ b/docs/_cpp_api/namespace_torch_tensorrt__logging.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/namespace_torch_tensorrt__ptq.html b/docs/_cpp_api/namespace_torch_tensorrt__ptq.html
index d0a5841287..02df82e956 100644
--- a/docs/_cpp_api/namespace_torch_tensorrt__ptq.html
+++ b/docs/_cpp_api/namespace_torch_tensorrt__ptq.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/namespace_torch_tensorrt__torchscript.html b/docs/_cpp_api/namespace_torch_tensorrt__torchscript.html
index b8de17ab87..50e6f82e8a 100644
--- a/docs/_cpp_api/namespace_torch_tensorrt__torchscript.html
+++ b/docs/_cpp_api/namespace_torch_tensorrt__torchscript.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_logging.h.html b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_logging.h.html
index 18ed4bc57b..a91a9daeef 100644
--- a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_logging.h.html
+++ b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_logging.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_macros.h.html b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_macros.h.html
index 8de4907e0d..379a7e9116 100644
--- a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_macros.h.html
+++ b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_macros.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_ptq.h.html b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_ptq.h.html
index 02eb4d45a7..5efe6c5ee3 100644
--- a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_ptq.h.html
+++ b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_ptq.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_torch_tensorrt.h.html b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_torch_tensorrt.h.html
index 1d8d673c26..b0a261c467 100644
--- a/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_torch_tensorrt.h.html
+++ b/docs/_cpp_api/program_listing_file_cpp_include_torch_tensorrt_torch_tensorrt.h.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/structtorch__tensorrt_1_1Device.html b/docs/_cpp_api/structtorch__tensorrt_1_1Device.html
index 1ed4e56127..fed41b4bb8 100644
--- a/docs/_cpp_api/structtorch__tensorrt_1_1Device.html
+++ b/docs/_cpp_api/structtorch__tensorrt_1_1Device.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/structtorch__tensorrt_1_1GraphInputs.html b/docs/_cpp_api/structtorch__tensorrt_1_1GraphInputs.html
index 8a0c6276f0..e32c670333 100644
--- a/docs/_cpp_api/structtorch__tensorrt_1_1GraphInputs.html
+++ b/docs/_cpp_api/structtorch__tensorrt_1_1GraphInputs.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/structtorch__tensorrt_1_1Input.html b/docs/_cpp_api/structtorch__tensorrt_1_1Input.html
index e8c52e9872..58e3d038c7 100644
--- a/docs/_cpp_api/structtorch__tensorrt_1_1Input.html
+++ b/docs/_cpp_api/structtorch__tensorrt_1_1Input.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/structtorch__tensorrt_1_1torchscript_1_1CompileSpec.html b/docs/_cpp_api/structtorch__tensorrt_1_1torchscript_1_1CompileSpec.html
index ca8428f9cb..18f9fb08b0 100644
--- a/docs/_cpp_api/structtorch__tensorrt_1_1torchscript_1_1CompileSpec.html
+++ b/docs/_cpp_api/structtorch__tensorrt_1_1torchscript_1_1CompileSpec.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/torch_tensort_cpp.html b/docs/_cpp_api/torch_tensort_cpp.html
index 92aee27d82..d9919dcc9a 100644
--- a/docs/_cpp_api/torch_tensort_cpp.html
+++ b/docs/_cpp_api/torch_tensort_cpp.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_cpp_api/unabridged_orphan.html b/docs/_cpp_api/unabridged_orphan.html
index f9653efe77..6cde3de016 100644
--- a/docs/_cpp_api/unabridged_orphan.html
+++ b/docs/_cpp_api/unabridged_orphan.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_downloads/0daf1d0af656cac7b808856b71e6616f/torch_compile_resnet_example.ipynb b/docs/_downloads/0daf1d0af656cac7b808856b71e6616f/torch_compile_resnet_example.ipynb
index 935722964f..e6c161f892 100644
--- a/docs/_downloads/0daf1d0af656cac7b808856b71e6616f/torch_compile_resnet_example.ipynb
+++ b/docs/_downloads/0daf1d0af656cac7b808856b71e6616f/torch_compile_resnet_example.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n\n# Compiling ResNet using the Torch-TensorRT `torch.compile` Backend\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a ResNet model.\n"
+ "\n\n# Compiling ResNet with dynamic shapes using the `torch.compile` backend\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a ResNet model.\n"
]
},
{
diff --git a/docs/_downloads/2a9ac10f2667047a7f398d1593b7ca33/torch_export_gpt2.py b/docs/_downloads/2a9ac10f2667047a7f398d1593b7ca33/torch_export_gpt2.py
index f9229e420c..cea0f3adf2 100644
--- a/docs/_downloads/2a9ac10f2667047a7f398d1593b7ca33/torch_export_gpt2.py
+++ b/docs/_downloads/2a9ac10f2667047a7f398d1593b7ca33/torch_export_gpt2.py
@@ -1,10 +1,10 @@
"""
.. _torch_export_gpt2:
-Compiling GPT2 using the Torch-TensorRT with dynamo backend
+Compiling GPT2 using the dynamo backend
==========================================================
-This interactive script is intended as a sample of the Torch-TensorRT workflow with dynamo backend on a GPT2 model."""
+This script illustrates Torch-TensorRT workflow with dynamo backend on popular GPT2 model."""
# %%
# Imports and Model Definition
@@ -88,13 +88,10 @@
tokenizer.decode(trt_gen_tokens[0], skip_special_tokens=True),
)
-# %%
-# The output sentences should look like
-# =============================
-# Pytorch model generated text: What is parallel programming ?
+# Prompt : What is parallel programming ?
-# The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
# =============================
-# TensorRT model generated text: What is parallel programming ?
+# Pytorch model generated text: The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
-# The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
+# =============================
+# TensorRT model generated text: The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
diff --git a/docs/_downloads/34421db2f2a82ea2b3d9a9cc85624784/torch_export_gpt2.ipynb b/docs/_downloads/34421db2f2a82ea2b3d9a9cc85624784/torch_export_gpt2.ipynb
index 6b09a33d5b..d14952a8ed 100644
--- a/docs/_downloads/34421db2f2a82ea2b3d9a9cc85624784/torch_export_gpt2.ipynb
+++ b/docs/_downloads/34421db2f2a82ea2b3d9a9cc85624784/torch_export_gpt2.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n\n# Compiling GPT2 using the Torch-TensorRT with dynamo backend\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with dynamo backend on a GPT2 model.\n"
+ "\n\n# Compiling GPT2 using the dynamo backend\n\nThis script illustrates Torch-TensorRT workflow with dynamo backend on popular GPT2 model.\n"
]
},
{
@@ -87,25 +87,7 @@
},
"outputs": [],
"source": [
- "print(\"=============================\")\nprint(\n \"Pytorch model generated text: \",\n tokenizer.decode(pyt_gen_tokens[0], skip_special_tokens=True),\n)\nprint(\"=============================\")\nprint(\n \"TensorRT model generated text: \",\n tokenizer.decode(trt_gen_tokens[0], skip_special_tokens=True),\n)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# The output sentences should look like\nPytorch model generated text: What is parallel programming ?\n\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that\n# =============================\n# TensorRT model generated text: What is parallel programming ?\n\n# The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that"
+ "print(\"=============================\")\nprint(\n \"Pytorch model generated text: \",\n tokenizer.decode(pyt_gen_tokens[0], skip_special_tokens=True),\n)\nprint(\"=============================\")\nprint(\n \"TensorRT model generated text: \",\n tokenizer.decode(trt_gen_tokens[0], skip_special_tokens=True),\n)\n\n# Prompt : What is parallel programming ?\n\n# =============================\n# Pytorch model generated text: The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that\n\n# =============================\n# TensorRT model generated text: The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that"
]
}
],
diff --git a/docs/_downloads/46b3e6febaab06324aa2715896895544/torch_compile_stable_diffusion.py b/docs/_downloads/46b3e6febaab06324aa2715896895544/torch_compile_stable_diffusion.py
index a0b725572b..fe49da74d1 100644
--- a/docs/_downloads/46b3e6febaab06324aa2715896895544/torch_compile_stable_diffusion.py
+++ b/docs/_downloads/46b3e6febaab06324aa2715896895544/torch_compile_stable_diffusion.py
@@ -1,7 +1,7 @@
"""
.. _torch_compile_stable_diffusion:
-Torch Compile Stable Diffusion
+Compiling Stable Diffusion model using the `torch.compile` backend
======================================================
This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a Stable Diffusion model. A sample output is featured below:
diff --git a/docs/_downloads/6a6052d9668b2cb8332d349d328e21c1/_rendered_examples_jupyter.zip b/docs/_downloads/6a6052d9668b2cb8332d349d328e21c1/_rendered_examples_jupyter.zip
index 1327b06a5c..850b2ffccd 100644
Binary files a/docs/_downloads/6a6052d9668b2cb8332d349d328e21c1/_rendered_examples_jupyter.zip and b/docs/_downloads/6a6052d9668b2cb8332d349d328e21c1/_rendered_examples_jupyter.zip differ
diff --git a/docs/_downloads/798cda8f83bd9f5e2cc93f329a04332c/_rendered_examples_python.zip b/docs/_downloads/798cda8f83bd9f5e2cc93f329a04332c/_rendered_examples_python.zip
index 36611286f0..ba5bf56b3b 100644
Binary files a/docs/_downloads/798cda8f83bd9f5e2cc93f329a04332c/_rendered_examples_python.zip and b/docs/_downloads/798cda8f83bd9f5e2cc93f329a04332c/_rendered_examples_python.zip differ
diff --git a/docs/_downloads/7b7004dc2ea6f839be532665e16e0426/torch_export_llama2.py b/docs/_downloads/7b7004dc2ea6f839be532665e16e0426/torch_export_llama2.py
index 11a0c93276..5cfd1ed61c 100644
--- a/docs/_downloads/7b7004dc2ea6f839be532665e16e0426/torch_export_llama2.py
+++ b/docs/_downloads/7b7004dc2ea6f839be532665e16e0426/torch_export_llama2.py
@@ -1,10 +1,10 @@
"""
.. _torch_export_llama2:
-Compiling Llama2 using the Torch-TensorRT with dynamo backend
+Compiling Llama2 using the dynamo backend
==========================================================
-This interactive script is intended as a sample of the Torch-TensorRT workflow with dynamo backend on a Llama2 model."""
+This script illustrates Torch-TensorRT workflow with dynamo backend on popular Llama2 model."""
# %%
# Imports and Model Definition
@@ -91,9 +91,11 @@
)[0],
)
-# %%
-# The output sentences should look like
+
+# Prompt : What is dynamic programming?
+
# =============================
-# Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
+# Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
+
# =============================
-# TensorRT model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
+# TensorRT model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
diff --git a/docs/_downloads/9e148ac48490c84d381ee281904f3226/torch_export_llama2.ipynb b/docs/_downloads/9e148ac48490c84d381ee281904f3226/torch_export_llama2.ipynb
index 171465315f..a90e28b6a3 100644
--- a/docs/_downloads/9e148ac48490c84d381ee281904f3226/torch_export_llama2.ipynb
+++ b/docs/_downloads/9e148ac48490c84d381ee281904f3226/torch_export_llama2.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n\n# Compiling Llama2 using the Torch-TensorRT with dynamo backend\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with dynamo backend on a Llama2 model.\n"
+ "\n\n# Compiling Llama2 using the dynamo backend\n\nThis script illustrates Torch-TensorRT workflow with dynamo backend on popular Llama2 model.\n"
]
},
{
@@ -94,14 +94,7 @@
},
"outputs": [],
"source": [
- "print(\"=============================\")\nprint(\n \"Pytorch model generated text: \",\n tokenizer.batch_decode(\n pyt_gen_tokens, skip_special_tokens=True, clean_up_tokenization_spaces=False\n )[0],\n)\nprint(\"=============================\")\nprint(\n \"TensorRT model generated text: \",\n tokenizer.batch_decode(\n trt_gen_tokens,\n skip_special_tokens=True,\n clean_up_tokenization_spaces=False,\n )[0],\n)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# The output sentences should look like\nPytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and\n=============================\nTensorRT model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and\n\n"
+ "print(\"=============================\")\nprint(\n \"Pytorch model generated text: \",\n tokenizer.batch_decode(\n pyt_gen_tokens, skip_special_tokens=True, clean_up_tokenization_spaces=False\n )[0],\n)\nprint(\"=============================\")\nprint(\n \"TensorRT model generated text: \",\n tokenizer.batch_decode(\n trt_gen_tokens,\n skip_special_tokens=True,\n clean_up_tokenization_spaces=False,\n )[0],\n)\n\n\n# Prompt : What is dynamic programming?\n\n# =============================\n# Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and\n\n# =============================\n# TensorRT model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and"
]
}
],
diff --git a/docs/_downloads/b776287bc876f7ce24942b82a66beb05/torch_compile_stable_diffusion.ipynb b/docs/_downloads/b776287bc876f7ce24942b82a66beb05/torch_compile_stable_diffusion.ipynb
index bc86c3dbd0..eac19f81a2 100644
--- a/docs/_downloads/b776287bc876f7ce24942b82a66beb05/torch_compile_stable_diffusion.ipynb
+++ b/docs/_downloads/b776287bc876f7ce24942b82a66beb05/torch_compile_stable_diffusion.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n\n# Torch Compile Stable Diffusion\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a Stable Diffusion model. A sample output is featured below:\n\n
![](\"file://tutorials/images/majestic_castle.png\")
\n"
+ "\n\n# Compiling Stable Diffusion model using the `torch.compile` backend\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a Stable Diffusion model. A sample output is featured below:\n\n\n"
]
},
{
diff --git a/docs/_downloads/ce102e287ddb5744f0a1364e8c0c7f68/torch_compile_transformers_example.ipynb b/docs/_downloads/ce102e287ddb5744f0a1364e8c0c7f68/torch_compile_transformers_example.ipynb
index 15fb754e33..74998c0164 100644
--- a/docs/_downloads/ce102e287ddb5744f0a1364e8c0c7f68/torch_compile_transformers_example.ipynb
+++ b/docs/_downloads/ce102e287ddb5744f0a1364e8c0c7f68/torch_compile_transformers_example.ipynb
@@ -4,7 +4,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n\n# Compiling a Transformer using torch.compile and TensorRT\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a transformer-based model.\n"
+ "\n\n# Compiling BERT using the `torch.compile` backend\n\nThis interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a BERT model.\n"
]
},
{
diff --git a/docs/_downloads/d6e1bb6ec5f884994554d9d12e37a0f6/torch_compile_resnet_example.py b/docs/_downloads/d6e1bb6ec5f884994554d9d12e37a0f6/torch_compile_resnet_example.py
index 420c5390d3..f852d60158 100644
--- a/docs/_downloads/d6e1bb6ec5f884994554d9d12e37a0f6/torch_compile_resnet_example.py
+++ b/docs/_downloads/d6e1bb6ec5f884994554d9d12e37a0f6/torch_compile_resnet_example.py
@@ -1,7 +1,7 @@
"""
.. _torch_compile_resnet:
-Compiling ResNet using the Torch-TensorRT `torch.compile` Backend
+Compiling ResNet with dynamic shapes using the `torch.compile` backend
==========================================================
This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a ResNet model."""
diff --git a/docs/_downloads/dfa60e8f9850fd7761f3e7da81304d32/torch_compile_transformers_example.py b/docs/_downloads/dfa60e8f9850fd7761f3e7da81304d32/torch_compile_transformers_example.py
index 01d46e96f6..221ecd4fd1 100644
--- a/docs/_downloads/dfa60e8f9850fd7761f3e7da81304d32/torch_compile_transformers_example.py
+++ b/docs/_downloads/dfa60e8f9850fd7761f3e7da81304d32/torch_compile_transformers_example.py
@@ -1,10 +1,10 @@
"""
.. _torch_compile_transformer:
-Compiling a Transformer using torch.compile and TensorRT
+Compiling BERT using the `torch.compile` backend
==============================================================
-This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a transformer-based model."""
+This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a BERT model."""
# %%
# Imports and Model Definition
diff --git a/docs/_modules/index.html b/docs/_modules/index.html
index 83cadc6bf4..3615078f82 100644
--- a/docs/_modules/index.html
+++ b/docs/_modules/index.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/_Device.html b/docs/_modules/torch_tensorrt/_Device.html
index ef99208912..4097ae403d 100644
--- a/docs/_modules/torch_tensorrt/_Device.html
+++ b/docs/_modules/torch_tensorrt/_Device.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/_Input.html b/docs/_modules/torch_tensorrt/_Input.html
index 329508c277..afc80b18fc 100644
--- a/docs/_modules/torch_tensorrt/_Input.html
+++ b/docs/_modules/torch_tensorrt/_Input.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/_compile.html b/docs/_modules/torch_tensorrt/_compile.html
index 46c40fab86..bbb05e45ad 100644
--- a/docs/_modules/torch_tensorrt/_compile.html
+++ b/docs/_modules/torch_tensorrt/_compile.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/_enums.html b/docs/_modules/torch_tensorrt/_enums.html
index 0eddca6ae1..679e76add5 100644
--- a/docs/_modules/torch_tensorrt/_enums.html
+++ b/docs/_modules/torch_tensorrt/_enums.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/_compiler.html b/docs/_modules/torch_tensorrt/dynamo/_compiler.html
index e6692da541..3bbf46f7a1 100644
--- a/docs/_modules/torch_tensorrt/dynamo/_compiler.html
+++ b/docs/_modules/torch_tensorrt/dynamo/_compiler.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/_exporter.html b/docs/_modules/torch_tensorrt/dynamo/_exporter.html
index 2151ccf4b1..b4768ff859 100644
--- a/docs/_modules/torch_tensorrt/dynamo/_exporter.html
+++ b/docs/_modules/torch_tensorrt/dynamo/_exporter.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/_refit.html b/docs/_modules/torch_tensorrt/dynamo/_refit.html
index c76378723c..4e2a2521e1 100644
--- a/docs/_modules/torch_tensorrt/dynamo/_refit.html
+++ b/docs/_modules/torch_tensorrt/dynamo/_refit.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/_settings.html b/docs/_modules/torch_tensorrt/dynamo/_settings.html
index dc8cf04759..a26d1286bc 100644
--- a/docs/_modules/torch_tensorrt/dynamo/_settings.html
+++ b/docs/_modules/torch_tensorrt/dynamo/_settings.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/_tracer.html b/docs/_modules/torch_tensorrt/dynamo/_tracer.html
index acf142d96e..9a9757f466 100644
--- a/docs/_modules/torch_tensorrt/dynamo/_tracer.html
+++ b/docs/_modules/torch_tensorrt/dynamo/_tracer.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/runtime/_MutableTorchTensorRTModule.html b/docs/_modules/torch_tensorrt/dynamo/runtime/_MutableTorchTensorRTModule.html
index 787c5f42d5..d308954efe 100644
--- a/docs/_modules/torch_tensorrt/dynamo/runtime/_MutableTorchTensorRTModule.html
+++ b/docs/_modules/torch_tensorrt/dynamo/runtime/_MutableTorchTensorRTModule.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/runtime/_PythonTorchTensorRTModule.html b/docs/_modules/torch_tensorrt/dynamo/runtime/_PythonTorchTensorRTModule.html
index 39a32bcab3..8af4c5987f 100644
--- a/docs/_modules/torch_tensorrt/dynamo/runtime/_PythonTorchTensorRTModule.html
+++ b/docs/_modules/torch_tensorrt/dynamo/runtime/_PythonTorchTensorRTModule.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/dynamo/runtime/_TorchTensorRTModule.html b/docs/_modules/torch_tensorrt/dynamo/runtime/_TorchTensorRTModule.html
index 821e1d0e56..3e2b1f3c88 100644
--- a/docs/_modules/torch_tensorrt/dynamo/runtime/_TorchTensorRTModule.html
+++ b/docs/_modules/torch_tensorrt/dynamo/runtime/_TorchTensorRTModule.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/fx/fx2trt.html b/docs/_modules/torch_tensorrt/fx/fx2trt.html
index 1d04f6da2d..34033c7fc1 100644
--- a/docs/_modules/torch_tensorrt/fx/fx2trt.html
+++ b/docs/_modules/torch_tensorrt/fx/fx2trt.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/fx/input_tensor_spec.html b/docs/_modules/torch_tensorrt/fx/input_tensor_spec.html
index 1d4f4033e3..52fd9deda4 100644
--- a/docs/_modules/torch_tensorrt/fx/input_tensor_spec.html
+++ b/docs/_modules/torch_tensorrt/fx/input_tensor_spec.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/fx/lower.html b/docs/_modules/torch_tensorrt/fx/lower.html
index 23884dbb3e..5af2085b5c 100644
--- a/docs/_modules/torch_tensorrt/fx/lower.html
+++ b/docs/_modules/torch_tensorrt/fx/lower.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/fx/trt_module.html b/docs/_modules/torch_tensorrt/fx/trt_module.html
index 80483f2411..8950295f0e 100644
--- a/docs/_modules/torch_tensorrt/fx/trt_module.html
+++ b/docs/_modules/torch_tensorrt/fx/trt_module.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/logging.html b/docs/_modules/torch_tensorrt/logging.html
index 4645268363..c2633900ce 100644
--- a/docs/_modules/torch_tensorrt/logging.html
+++ b/docs/_modules/torch_tensorrt/logging.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/runtime/_multi_device_safe_mode.html b/docs/_modules/torch_tensorrt/runtime/_multi_device_safe_mode.html
index afe353e511..f7df228f6f 100644
--- a/docs/_modules/torch_tensorrt/runtime/_multi_device_safe_mode.html
+++ b/docs/_modules/torch_tensorrt/runtime/_multi_device_safe_mode.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/ts/_compile_spec.html b/docs/_modules/torch_tensorrt/ts/_compile_spec.html
index 53e6b7cdd7..00d1431fac 100644
--- a/docs/_modules/torch_tensorrt/ts/_compile_spec.html
+++ b/docs/_modules/torch_tensorrt/ts/_compile_spec.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/ts/_compiler.html b/docs/_modules/torch_tensorrt/ts/_compiler.html
index 89c6d8297e..996656d4f9 100644
--- a/docs/_modules/torch_tensorrt/ts/_compiler.html
+++ b/docs/_modules/torch_tensorrt/ts/_compiler.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_modules/torch_tensorrt/ts/ptq.html b/docs/_modules/torch_tensorrt/ts/ptq.html
index f3244728c3..197bd4c2d4 100644
--- a/docs/_modules/torch_tensorrt/ts/ptq.html
+++ b/docs/_modules/torch_tensorrt/ts/ptq.html
@@ -9,7 +9,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -317,6 +317,11 @@
Dynamo Frontend
-
@@ -336,22 +341,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/_sources/index.rst.txt b/docs/_sources/index.rst.txt
index eaf547d60e..b3d90055cf 100644
--- a/docs/_sources/index.rst.txt
+++ b/docs/_sources/index.rst.txt
@@ -54,6 +54,11 @@ User Guide
tutorials/_rendered_examples/dynamo/vgg16_ptq
tutorials/_rendered_examples/dynamo/engine_caching_example
tutorials/_rendered_examples/dynamo/refit_engine_example
+ tutorials/serving_torch_tensorrt_with_triton
+ tutorials/_rendered_examples/dynamo/torch_export_cudagraphs
+ tutorials/_rendered_examples/dynamo/converter_overloading
+ tutorials/_rendered_examples/dynamo/custom_kernel_plugins
+ tutorials/_rendered_examples/dynamo/mutable_torchtrt_module_example
Dynamo Frontend
----------------
@@ -99,30 +104,28 @@ FX Frontend
fx/getting_started_with_fx_path
-Tutorials
+Model Zoo
------------
-* :ref:`torch_tensorrt_tutorials`
-* :ref:`serving_torch_tensorrt_with_triton`
+* :ref:`torch_compile_resnet`
+* :ref:`torch_compile_transformer`
+* :ref:`torch_compile_stable_diffusion`
+* :ref:`torch_export_gpt2`
+* :ref:`torch_export_llama2`
* :ref:`notebooks`
.. toctree::
- :caption: Tutorials
+ :caption: Model Zoo
:maxdepth: 3
:hidden:
-
- tutorials/serving_torch_tensorrt_with_triton
- tutorials/notebooks
+
tutorials/_rendered_examples/dynamo/torch_compile_resnet_example
tutorials/_rendered_examples/dynamo/torch_compile_transformers_example
tutorials/_rendered_examples/dynamo/torch_compile_stable_diffusion
- tutorials/_rendered_examples/dynamo/torch_export_cudagraphs
- tutorials/_rendered_examples/dynamo/converter_overloading
- tutorials/_rendered_examples/dynamo/custom_kernel_plugins
tutorials/_rendered_examples/distributed_inference/data_parallel_gpt2
tutorials/_rendered_examples/distributed_inference/data_parallel_stable_diffusion
- tutorials/_rendered_examples/dynamo/mutable_torchtrt_module_example
tutorials/_rendered_examples/dynamo/torch_export_gpt2
tutorials/_rendered_examples/dynamo/torch_export_llama2
+ tutorials/notebooks
Python API Documentation
------------------------
diff --git a/docs/_sources/tutorials/_rendered_examples/dynamo/index.rst.txt b/docs/_sources/tutorials/_rendered_examples/dynamo/index.rst.txt
index 17b6bc2a85..cb28b2b62b 100644
--- a/docs/_sources/tutorials/_rendered_examples/dynamo/index.rst.txt
+++ b/docs/_sources/tutorials/_rendered_examples/dynamo/index.rst.txt
@@ -2,13 +2,9 @@
.. _sphx_glr_tutorials__rendered_examples_dynamo:
-.. _torch_compile:
+.. _torch_tensorrt_examples:
-Torch-TensorRT Examples
-====================================
-
-Please refer to the following examples which demonstrate the usage of different features of Torch-TensorRT. We also provide
-examples of Torch-TensorRT compilation of select computer vision and language models.
+Here we provide examples of Torch-TensorRT compilation of popular computer vision and language models.
Dependencies
------------------------------------
@@ -20,18 +16,6 @@ Please install the following external dependencies (assuming you already have co
pip install -r requirements.txt
-Compiler Features
-------------------------------------
-* :ref:`torch_compile_advanced_usage`: Advanced usage including making a custom backend to use directly with the ``torch.compile`` API
-* :ref:`torch_export_cudagraphs`: Using the Cudagraphs integration with `ir="dynamo"`
-* :ref:`converter_overloading`: How to write custom converters and overload existing ones
-* :ref:`custom_kernel_plugins`: Creating a plugin to use a custom kernel inside TensorRT engines
-* :ref:`refit_engine_example`: Refitting a compiled TensorRT Graph Module with updated weights
-* :ref:`mutable_torchtrt_module_example`: Compile, use, and modify TensorRT Graph Module with MutableTorchTensorRTModule
-* :ref:`vgg16_fp8_ptq`: Compiling a VGG16 model with FP8 and PTQ using ``torch.compile``
-* :ref:`engine_caching_example`: Utilizing engine caching to speed up compilation times
-* :ref:`engine_caching_bert_example`: Demonstrating engine caching on BERT
-
Model Zoo
------------------------------------
* :ref:`torch_compile_resnet`: Compiling a ResNet model using the Torch Compile Frontend for ``torch_tensorrt.compile``
@@ -59,7 +43,7 @@ Model Zoo
.. raw:: html
-
Torch Compile Stable Diffusion
+ Compiling Stable Diffusion model using the torch.compile backend
@@ -110,7 +94,7 @@ Model Zoo
.. raw:: html
- Compiling a Transformer using torch.compile and TensorRT
+ Compiling BERT using the torch.compile backend
@@ -150,69 +134,69 @@ Model Zoo
.. raw:: html
-
+
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_llama2_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_mutable_torchtrt_module_example_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_llama2.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_mutable_torchtrt_module_example.py`
.. raw:: html
-
.. raw:: html
- Compiling Llama2 using the Torch-TensorRT with dynamo backend
+ Mutable Torch TensorRT Module
+
@@ -166,69 +146,69 @@ Model Zoo
.. raw:: html
-
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_mutable_torchtrt_module_example_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_compile_resnet_example_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_mutable_torchtrt_module_example.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_compile_resnet_example.py`
.. raw:: html
-
.. raw:: html
- Mutable Torch TensorRT Module
+ Compiling ResNet with dynamic shapes using the torch.compile backend
+
@@ -126,7 +106,7 @@ Model Zoo
.. raw:: html
-
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_compile_resnet_example_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_gpt2_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_compile_resnet_example.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_gpt2.py`
.. raw:: html
-
.. raw:: html
- Compiling ResNet using the Torch-TensorRT torch.compile Backend
+ Compiling GPT2 using the dynamo backend
+
-Torch-TensorRT Examples
-====================================
-
-Please refer to the following examples which demonstrate the usage of different features of Torch-TensorRT. We also provide
-examples of Torch-TensorRT compilation of select computer vision and language models.
+Here we provide examples of Torch-TensorRT compilation of popular computer vision and language models.
Dependencies
------------------------------------
@@ -36,18 +28,6 @@ Please install the following external dependencies (assuming you already have co
pip install -r requirements.txt
-Compiler Features
-------------------------------------
-* :ref:`torch_compile_advanced_usage`: Advanced usage including making a custom backend to use directly with the ``torch.compile`` API
-* :ref:`torch_export_cudagraphs`: Using the Cudagraphs integration with `ir="dynamo"`
-* :ref:`converter_overloading`: How to write custom converters and overload existing ones
-* :ref:`custom_kernel_plugins`: Creating a plugin to use a custom kernel inside TensorRT engines
-* :ref:`refit_engine_example`: Refitting a compiled TensorRT Graph Module with updated weights
-* :ref:`mutable_torchtrt_module_example`: Compile, use, and modify TensorRT Graph Module with MutableTorchTensorRTModule
-* :ref:`vgg16_fp8_ptq`: Compiling a VGG16 model with FP8 and PTQ using ``torch.compile``
-* :ref:`engine_caching_example`: Utilizing engine caching to speed up compilation times
-* :ref:`engine_caching_bert_example`: Demonstrating engine caching on BERT
-
Model Zoo
------------------------------------
* :ref:`torch_compile_resnet`: Compiling a ResNet model using the Torch Compile Frontend for ``torch_tensorrt.compile``
@@ -75,7 +55,7 @@ Model Zoo
.. raw:: html
-
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_gpt2_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_llama2_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_gpt2.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_llama2.py`
.. raw:: html
-
@@ -298,10 +282,10 @@ Model Zoo
/tutorials/_rendered_examples/dynamo/torch_compile_transformers_example
/tutorials/_rendered_examples/dynamo/torch_compile_advanced_usage
/tutorials/_rendered_examples/dynamo/engine_caching_bert_example
- /tutorials/_rendered_examples/dynamo/torch_export_llama2
/tutorials/_rendered_examples/dynamo/mutable_torchtrt_module_example
/tutorials/_rendered_examples/dynamo/torch_compile_resnet_example
/tutorials/_rendered_examples/dynamo/torch_export_gpt2
+ /tutorials/_rendered_examples/dynamo/torch_export_llama2
/tutorials/_rendered_examples/dynamo/converter_overloading
/tutorials/_rendered_examples/dynamo/vgg16_ptq
/tutorials/_rendered_examples/dynamo/engine_caching_example
diff --git a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_resnet_example.rst.txt b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_resnet_example.rst.txt
index a223ad9d2d..ca4980988e 100644
--- a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_resnet_example.rst.txt
+++ b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_resnet_example.rst.txt
@@ -20,7 +20,7 @@
.. _torch_compile_resnet:
-Compiling ResNet using the Torch-TensorRT `torch.compile` Backend
+Compiling ResNet with dynamic shapes using the `torch.compile` backend
==========================================================
This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a ResNet model.
diff --git a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_stable_diffusion.rst.txt b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_stable_diffusion.rst.txt
index eb8f53aa4b..30873dcde5 100644
--- a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_stable_diffusion.rst.txt
+++ b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_stable_diffusion.rst.txt
@@ -20,7 +20,7 @@
.. _torch_compile_stable_diffusion:
-Torch Compile Stable Diffusion
+Compiling Stable Diffusion model using the `torch.compile` backend
======================================================
This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a Stable Diffusion model. A sample output is featured below:
diff --git a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_transformers_example.rst.txt b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_transformers_example.rst.txt
index b362e42447..8021e43c34 100644
--- a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_transformers_example.rst.txt
+++ b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_compile_transformers_example.rst.txt
@@ -20,10 +20,10 @@
.. _torch_compile_transformer:
-Compiling a Transformer using torch.compile and TensorRT
+Compiling BERT using the `torch.compile` backend
==============================================================
-This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a transformer-based model.
+This interactive script is intended as a sample of the Torch-TensorRT workflow with `torch.compile` on a BERT model.
.. GENERATED FROM PYTHON SOURCE LINES 10-12
diff --git a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_gpt2.rst.txt b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_gpt2.rst.txt
index c692ccc2d3..db986554f2 100644
--- a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_gpt2.rst.txt
+++ b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_gpt2.rst.txt
@@ -20,10 +20,10 @@
.. _torch_export_gpt2:
-Compiling GPT2 using the Torch-TensorRT with dynamo backend
+Compiling GPT2 using the dynamo backend
==========================================================
-This interactive script is intended as a sample of the Torch-TensorRT workflow with dynamo backend on a GPT2 model.
+This script illustrates Torch-TensorRT workflow with dynamo backend on popular GPT2 model.
.. GENERATED FROM PYTHON SOURCE LINES 10-12
@@ -123,7 +123,7 @@ Compilation with `Torch-TensorRT` using dynamo backend and generate TensorRT out
Decode the output sentences of PyTorch and TensorRT
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-.. GENERATED FROM PYTHON SOURCE LINES 80-91
+.. GENERATED FROM PYTHON SOURCE LINES 80-98
.. code-block:: python
@@ -138,23 +138,13 @@ Decode the output sentences of PyTorch and TensorRT
tokenizer.decode(trt_gen_tokens[0], skip_special_tokens=True),
)
+ # Prompt : What is parallel programming ?
-.. GENERATED FROM PYTHON SOURCE LINES 92-95
-
-The output sentences should look like
-=============================
-Pytorch model generated text: What is parallel programming ?
-
-.. GENERATED FROM PYTHON SOURCE LINES 95-101
-
-.. code-block:: python
-
-
- # The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
# =============================
- # TensorRT model generated text: What is parallel programming ?
+ # Pytorch model generated text: The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
- # The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
+ # =============================
+ # TensorRT model generated text: The parallel programming paradigm is a set of programming languages that are designed to be used in parallel. The main difference between parallel programming and parallel programming is that
.. rst-class:: sphx-glr-timing
diff --git a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_llama2.rst.txt b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_llama2.rst.txt
index 5c86d845a4..c142aa76d4 100644
--- a/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_llama2.rst.txt
+++ b/docs/_sources/tutorials/_rendered_examples/dynamo/torch_export_llama2.rst.txt
@@ -20,10 +20,10 @@
.. _torch_export_llama2:
-Compiling Llama2 using the Torch-TensorRT with dynamo backend
+Compiling Llama2 using the dynamo backend
==========================================================
-This interactive script is intended as a sample of the Torch-TensorRT workflow with dynamo backend on a Llama2 model.
+This script illustrates Torch-TensorRT workflow with dynamo backend on popular Llama2 model.
.. GENERATED FROM PYTHON SOURCE LINES 10-12
@@ -123,7 +123,7 @@ Compilation with `Torch-TensorRT` using dynamo backend and generate TensorRT out
Decode the output sentences of PyTorch and TensorRT
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-.. GENERATED FROM PYTHON SOURCE LINES 77-94
+.. GENERATED FROM PYTHON SOURCE LINES 77-102
.. code-block:: python
@@ -145,13 +145,13 @@ Decode the output sentences of PyTorch and TensorRT
)
-.. GENERATED FROM PYTHON SOURCE LINES 95-100
+ # Prompt : What is dynamic programming?
-The output sentences should look like
-=============================
-Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
-=============================
-TensorRT model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
+ # =============================
+ # Pytorch model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
+
+ # =============================
+ # TensorRT model generated text: Dynamic programming is an algorithmic technique used to solve complex problems by breaking them down into smaller subproblems, solving each subproblem only once, and
.. rst-class:: sphx-glr-timing
diff --git a/docs/_sources/tutorials/_rendered_examples/index.rst.txt b/docs/_sources/tutorials/_rendered_examples/index.rst.txt
index 1f397896e1..0acd41a003 100644
--- a/docs/_sources/tutorials/_rendered_examples/index.rst.txt
+++ b/docs/_sources/tutorials/_rendered_examples/index.rst.txt
@@ -5,10 +5,6 @@
Torch-TensorRT Tutorials
===========================
-The user guide covers the basic concepts and usage of Torch-TensorRT.
-We also provide a number of tutorials to explore specific usecases and advanced concepts
-
-
.. raw:: html
@@ -20,11 +16,7 @@ We also provide a number of tutorials to explore specific usecases and advanced
Compiling GPT2 using the Torch-TensorRT with dynamo backend
+ Compiling Llama2 using the dynamo backend
Torch Compile Stable Diffusion
+ Compiling Stable Diffusion model using the torch.compile backend
Compiling a Transformer using torch.compile and TensorRT
+ Compiling BERT using the torch.compile backend
+
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_llama2_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_mutable_torchtrt_module_example_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_llama2.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_mutable_torchtrt_module_example.py`
.. raw:: html
-
.. raw:: html
- Compiling Llama2 using the Torch-TensorRT with dynamo backend
+ Mutable Torch TensorRT Module
+
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_mutable_torchtrt_module_example_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_compile_resnet_example_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_mutable_torchtrt_module_example.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_compile_resnet_example.py`
.. raw:: html
-
.. raw:: html
- Mutable Torch TensorRT Module
+ Compiling ResNet with dynamic shapes using the torch.compile backend
+
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_compile_resnet_example_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_gpt2_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_compile_resnet_example.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_gpt2.py`
.. raw:: html
-
.. raw:: html
- Compiling ResNet using the Torch-TensorRT torch.compile Backend
+ Compiling GPT2 using the dynamo backend
+ torchtrtc — Torch-TensorRT v2.6.0.dev0+743fdbd documentation
+ torchtrtc — Torch-TensorRT v2.6.0.dev0+2c517be documentation
@@ -275,7 +275,7 @@
.. only:: html
- .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_gpt2_thumb.png
+ .. image:: /tutorials/_rendered_examples/dynamo/images/thumb/sphx_glr_torch_export_llama2_thumb.png
:alt:
- :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_gpt2.py`
+ :ref:`sphx_glr_tutorials__rendered_examples_dynamo_torch_export_llama2.py`
.. raw:: html
-
diff --git a/docs/_sources/tutorials/notebooks.rst.txt b/docs/_sources/tutorials/notebooks.rst.txt
index 14737a8f63..509676d83a 100644
--- a/docs/_sources/tutorials/notebooks.rst.txt
+++ b/docs/_sources/tutorials/notebooks.rst.txt
@@ -1,10 +1,9 @@
.. _notebooks:
-Example notebooks
+Legacy notebooks
===================
-There exists a number of notebooks which cover specific using specific features and models
-with Torch-TensorRT
+There exists a number of notebooks which demonstrate different model conversions / features / frontends available within Torch-TensorRT
Notebooks
------------
diff --git a/docs/_static/documentation_options.js b/docs/_static/documentation_options.js
index 9b22b62560..d58ad172d7 100644
--- a/docs/_static/documentation_options.js
+++ b/docs/_static/documentation_options.js
@@ -1,6 +1,6 @@
var DOCUMENTATION_OPTIONS = {
URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
- VERSION: 'v2.6.0.dev0+743fdbd',
+ VERSION: 'v2.6.0.dev0+2c517be',
LANGUAGE: 'en',
COLLAPSE_INDEX: false,
BUILDER: 'html',
diff --git a/docs/cli/torchtrtc.html b/docs/cli/torchtrtc.html
index 776ba00304..743fdf4da5 100644
--- a/docs/cli/torchtrtc.html
+++ b/docs/cli/torchtrtc.html
@@ -10,7 +10,7 @@
- Compiling GPT2 using the Torch-TensorRT with dynamo backend
+ Compiling Llama2 using the dynamo backend
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/conversion.html b/docs/contributors/conversion.html
index 46bfc363c4..ef5b6309c3 100644
--- a/docs/contributors/conversion.html
+++ b/docs/contributors/conversion.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/dynamo_converters.html b/docs/contributors/dynamo_converters.html
index 9a2d0ea8d7..bd36c498bc 100644
--- a/docs/contributors/dynamo_converters.html
+++ b/docs/contributors/dynamo_converters.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/lowering.html b/docs/contributors/lowering.html
index 95c458ae35..f2d3220f6d 100644
--- a/docs/contributors/lowering.html
+++ b/docs/contributors/lowering.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/partitioning.html b/docs/contributors/partitioning.html
index 17885f5bc4..d7d35c1738 100644
--- a/docs/contributors/partitioning.html
+++ b/docs/contributors/partitioning.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/phases.html b/docs/contributors/phases.html
index a05ec986b4..1a1d0fe9ab 100644
--- a/docs/contributors/phases.html
+++ b/docs/contributors/phases.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -318,6 +318,11 @@
Dynamo Frontend
-
@@ -337,22 +342,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/runtime.html b/docs/contributors/runtime.html
index 9b253e17d3..5975edfb16 100644
--- a/docs/contributors/runtime.html
+++ b/docs/contributors/runtime.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/system_overview.html b/docs/contributors/system_overview.html
index b71b7f7da3..e2c8110d59 100644
--- a/docs/contributors/system_overview.html
+++ b/docs/contributors/system_overview.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/ts_converters.html b/docs/contributors/ts_converters.html
index d6a4ab8350..1b7be0e91d 100644
--- a/docs/contributors/ts_converters.html
+++ b/docs/contributors/ts_converters.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/useful_links.html b/docs/contributors/useful_links.html
index c781406839..1beb8d0c46 100644
--- a/docs/contributors/useful_links.html
+++ b/docs/contributors/useful_links.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/contributors/writing_dynamo_aten_lowering_passes.html b/docs/contributors/writing_dynamo_aten_lowering_passes.html
index 4f71bd6ffe..407121e822 100644
--- a/docs/contributors/writing_dynamo_aten_lowering_passes.html
+++ b/docs/contributors/writing_dynamo_aten_lowering_passes.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/dynamo/dynamo_export.html b/docs/dynamo/dynamo_export.html
index e23e73f061..9f9e08496c 100644
--- a/docs/dynamo/dynamo_export.html
+++ b/docs/dynamo/dynamo_export.html
@@ -10,7 +10,7 @@
-
- v2.6.0.dev0+743fdbd
+ v2.6.0.dev0+2c517be
@@ -320,6 +320,11 @@
Dynamo Frontend
-
@@ -339,22 +344,14 @@
-
Tutorials
+Model Zoo
-
-
Python API Documentation
-
diff --git a/docs/dynamo/torch_compile.html b/docs/dynamo/torch_compile.html
index e4fb16ae75..0f0a1278c9 100644
--- a/docs/dynamo/torch_compile.html
+++ b/docs/dynamo/torch_compile.html
@@ -10,7 +10,7 @@
-