refactor: rename the last bits of the old name

Signed-off-by: Naren Dasan <[email protected]>
Signed-off-by: Naren Dasan <[email protected]>

Author: narendasan

examples/custom_converters/README.md

@@ -1,16 +1,16 @@
 # Create a new op in C++, compile it to .so library and load it in Python
 
-There are some operators in PyTorch library which are not supported in TRTorch.
+There are some operators in PyTorch library which are not supported in Torch-TensorRT.
 To support these ops, users can register converters for missing ops. For example,
-if we try to compile a graph with a build of TRTorch that doesn't support the
+if we try to compile a graph with a build of Torch-TensorRT that doesn't support the
 [ELU](https://pytorch.org/docs/stable/generated/torch.nn.ELU.html) operation,
 we will get following error:
 
 > Unable to convert node: %result.2 : Tensor = aten::elu(%x.1, %2, %3, %3) # /home/bowa/.local/lib/python3.6/site-packages/torch/nn/functional.py:1227:17 (conversion.AddLayer)
 Schema: aten::elu(Tensor self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1) -> (Tensor)
 Converter for aten::elu requested, but no such converter was found.
 If you need a converter for this operator, you can try implementing one yourself
-or request a converter: https://www.github.com/NVIDIA/TRTorch/issues
+or request a converter: https://www.github.com/NVIDIA/Torch-TensorRT/issues
 
 Note that ELU converter is now supported in our library. If you want to get above
 error and run the example in this document, you can either:

examples/custom_converters/elu_converter/setup.py

@@ -4,16 +4,16 @@
 
 
 # library_dirs should point to the libtrtorch.so, include_dirs should point to the dir that include the headers
-# 1) download the latest package from https://github.com/NVIDIA/TRTorch/releases/
+# 1) download the latest package from https://github.com/NVIDIA/Torch-TensorRT/releases/
 # 2) Extract the file from downloaded package, we will get the "trtorch" directory
 # 3) Set trtorch_path to that directory
-trtorch_path = <PATH TO TRTORCH>
+torchtrt_path = <PATH TO TORCHTRT>
 
 ext_modules = [
     cpp_extension.CUDAExtension('elu_converter', ['./csrc/elu_converter.cpp'],
-                                library_dirs=[(trtorch_path + "/lib/")],
-                                libraries=["trtorch"],
-                                include_dirs=[trtorch_path + "/include/trtorch/"])
+                                library_dirs=[(torchtrt_path + "/lib/")],
+                                libraries=["torchtrt"],
+                                include_dirs=[torchtrt_path + "/include/torch_tensorrt/"])
 ]
 
 setup(

examples/int8/ptq/Makefile

@@ -1,7 +1,7 @@
 CXX=g++
 DEP_DIR=$(PWD)/deps
 CUDA_VERSION?=11.1
-ROOT_DIR?="../../../" # path to TRTorch directory (including TRTorch)
+ROOT_DIR?="../../../" # path to Torch-TensorRT directory (including Torch-TensorRT)
 INCLUDE_DIRS=-I$(DEP_DIR)/libtorch/include  -I$(ROOT_DIR) -I$(DEP_DIR)/torch_tensorrt/include -I$(DEP_DIR)/libtorch/include/torch/csrc/api/include/ -I/usr/local/cuda-$(CUDA_VERSION)/include -I$(DEP_DIR)/tensorrt/include
 LIB_DIRS=-L$(DEP_DIR)/torch_tensorrt/lib -L$(DEP_DIR)/libtorch/lib -L/usr/local/cuda-$(CUDA_VERSION)/lib64
 LIBS=-ltorchtrt -ltorch -ltorch_cuda -ltorch_cpu -ltorch_global_deps -lbackend_with_compiler -lc10 -lc10_cuda -lpthread -lcudart

examples/int8/ptq/README.md

@@ -4,9 +4,9 @@
 
 Post Training Quantization (PTQ) is a technique to reduce the required computational resources for inference while still preserving the accuracy of your model by mapping the traditional FP32 activation space to a reduced INT8 space. TensorRT uses a calibration step which executes your model with sample data from the target domain and track the activations in FP32 to calibrate a mapping to INT8 that minimizes the information loss between FP32 inference and INT8 inference.
 
-Users writing TensorRT applications are required to setup a calibrator class which will provide sample data to the TensorRT calibrator. With TRTorch we look to leverage existing infrastructure in PyTorch to make implementing calibrators easier.
+Users writing TensorRT applications are required to setup a calibrator class which will provide sample data to the TensorRT calibrator. With Torch-TensorRT we look to leverage existing infrastructure in PyTorch to make implementing calibrators easier.
 
-LibTorch provides a `Dataloader` and `Dataset` API which steamlines preprocessing and batching input data. TRTorch uses Dataloaders as the base of a generic calibrator implementation. So you will be able to reuse or quickly implement a `torch::Dataset` for your target domain, place it in a Dataloader and create a INT8 Calibrator from it which you can provide to TRTorch to run INT8 Calibration during compliation of your module.
+LibTorch provides a `Dataloader` and `Dataset` API which steamlines preprocessing and batching input data. Torch-TensorRT uses Dataloaders as the base of a generic calibrator implementation. So you will be able to reuse or quickly implement a `torch::Dataset` for your target domain, place it in a Dataloader and create a INT8 Calibrator from it which you can provide to Torch-TensorRT to run INT8 Calibration during compliation of your module.
 
 ### Code
 
@@ -115,7 +115,7 @@ From here not much changes in terms of how to execution works. You are still abl
 
 ## Running the Example Application
 
-This is a short example application that shows how to use TRTorch to perform post-training quantization for a module.
+This is a short example application that shows how to use Torch-TensorRT to perform post-training quantization for a module.
 
 ## Prerequisites
 
@@ -139,11 +139,11 @@ This will build a binary named `ptq` in `bazel-out/k8-<opt|dbg>/bin/cpp/int8/ptq
 
 ## Compilation using Makefile
 
-1) Download releases of <a href="https://pytorch.org">LibTorch</a>, <a href="https://github.com/NVIDIA/TRTorch/releases">TRTorch </a>and <a href="https://developer.nvidia.com/nvidia-tensorrt-download">TensorRT</a> and unpack them in the deps directory.
+1) Download releases of <a href="https://pytorch.org">LibTorch</a>, <a href="https://github.com/NVIDIA/Torch-TensorRT/releases">Torch-TensorRT </a>and <a href="https://developer.nvidia.com/nvidia-tensorrt-download">TensorRT</a> and unpack them in the deps directory.
 
 ```sh
 cd examples/torch_tensorrtrt_example/deps
-# Download latest TRTorch release tar file (libtorch_tensorrt.tar.gz) from https://github.com/NVIDIA/TRTorch/releases
+# Download latest Torch-TensorRT release tar file (libtorch_tensorrt.tar.gz) from https://github.com/NVIDIA/Torch-TensorRT/releases
 tar -xvzf libtorch_tensorrt.tar.gz
 # unzip libtorch downloaded from pytorch.org
 unzip libtorch.zip
@@ -161,9 +161,9 @@ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/deps/torch_tensorrt/lib:$(pwd)/de
 
 2) Build and run `ptq`
 
-We import header files `cifar10.h` and `benchmark.h` from `ROOT_DIR`. `ROOT_DIR` should point to the path where TRTorch is located `<path_to_TRTORCH>`.
+We import header files `cifar10.h` and `benchmark.h` from `ROOT_DIR`. `ROOT_DIR` should point to the path where Torch-TensorRT is located `<path_to_TRTORCH>`.
 
-By default it is set to `../../../`. If your TRTorch directory structure is different, please set `ROOT_DIR` accordingly.
+By default it is set to `../../../`. If your Torch-TensorRT directory structure is different, please set `ROOT_DIR` accordingly.
 
 ```sh
 cd examples/int8/ptq

examples/int8/qat/Makefile

@@ -1,7 +1,7 @@
 CXX=g++
 DEP_DIR=$(PWD)/deps
 CUDA_VERSION?=11.1
-ROOT_DIR?="../../../" # path to TRTorch directory (including TRTorch)
+ROOT_DIR?="../../../" # path to Torch-TensorRT directory (including Torch-TensorRT)
 INCLUDE_DIRS=-I$(DEP_DIR)/libtorch/include  -I$(ROOT_DIR) -I$(DEP_DIR)/torch_tensorrt/include -I$(DEP_DIR)/libtorch/include/torch/csrc/api/include/ -I/usr/local/cuda-$(CUDA_VERSION)/include -I$(DEP_DIR)/tensorrt/include
 LIB_DIRS=-L$(DEP_DIR)/torch_tensorrt/lib -L$(DEP_DIR)/libtorch/lib -L/usr/local/cuda-$(CUDA_VERSION)/lib64
 LIBS=-ltorchtrt -ltorch -ltorch_cuda -ltorch_cpu -ltorch_global_deps -lbackend_with_compiler -lc10 -lc10_cuda -lpthread -lcudart

examples/int8/qat/README.md

@@ -55,7 +55,7 @@ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/deps/torch_tensorrt/lib:$(pwd)/de
 
 2) Build and run `qat`
 
-We import header files `cifar10.h` and `benchmark.h` from `ROOT_DIR`. `ROOT_DIR` should point to the path where Torch-TensorRT is located `<path_to_TRTORCH>`.
+We import header files `cifar10.h` and `benchmark.h` from `ROOT_DIR`. `ROOT_DIR` should point to the path where Torch-TensorRT is located `<path_to_torch_tensorrt>`.
 
 By default it is set to `../../../`. If your Torch-TensorRT directory structure is different, please set `ROOT_DIR` accordingly.
 

examples/int8/training/vgg16/finetune_qat.py

@@ -21,7 +21,7 @@
 
 from vgg16 import vgg16
 
-PARSER = argparse.ArgumentParser(description="VGG16 example to use with TRTorch PTQ")
+PARSER = argparse.ArgumentParser(description="VGG16 example to use with Torch-TensorRT PTQ")
 PARSER.add_argument('--epochs', default=100, type=int, help="Number of total epochs to train")
 PARSER.add_argument('--enable_qat', action="store_true", help="Enable quantization aware training. This is recommended to perform on a pre-trained model.")
 PARSER.add_argument('--batch-size', default=128, type=int, help="Batch size to use when training")

examples/int8/training/vgg16/main.py

@@ -15,7 +15,7 @@
 
 from vgg16 import vgg16
 
-PARSER = argparse.ArgumentParser(description="VGG16 example to use with TRTorch PTQ")
+PARSER = argparse.ArgumentParser(description="VGG16 example to use with Torch-TensorRT PTQ")
 PARSER.add_argument('--epochs', default=100, type=int, help="Number of total epochs to train")
 PARSER.add_argument('--batch-size', default=128, type=int, help="Batch size to use when training")
 PARSER.add_argument('--lr', default=0.1, type=float, help="Initial learning rate")

examples/int8/training/vgg16/test_qat.py

@@ -78,14 +78,14 @@ def test(model, dataloader, crit):
 test_loss, test_acc = test(jit_model, testing_dataloader, crit)
 print("[JIT] Test Loss: {:.5f} Test Acc: {:.2f}%".format(test_loss, 100 * test_acc))
 
-import trtorch
+import torch_tensorrt as torchtrt
 # trtorch.logging.set_reportable_log_level(trtorch.logging.Level.Debug)
 compile_settings = {
-"inputs": [trtorch.Input([1, 3, 32, 32])],
-"op_precision": torch.int8 # Run with FP16
+"inputs": [torchtrt.Input([1, 3, 32, 32])],
+"enabled_precisions": {torch.float, torch.half, torch.int8} # Run with FP16
 }
 new_mod = torch.jit.load('trained_vgg16_qat.jit.pt')
-trt_ts_module = trtorch.compile(new_mod, compile_settings)
+trt_ts_module = torchtrt.compile(new_mod, compile_settings)
 testing_dataloader = torch.utils.data.DataLoader(testing_dataset, batch_size=1, shuffle=False, num_workers=2)
 test_loss, test_acc = test(trt_ts_module, testing_dataloader, crit)
 print("[TRTorch] Test Loss: {:.5f} Test Acc: {:.2f}%".format(test_loss, 100 * test_acc))

examples/torchtrt_runtime_example/network.py

@@ -1,6 +1,6 @@
 import torch
 import torch.nn as nn
-import trtorch
+import torch_tensorrt as torchtrt
 
 # create a simple norm layer.
 # This norm layer uses NormalizePlugin from TRTorch
@@ -30,16 +30,16 @@ def main():
     scripted_model = torch.jit.script(model)
 
     compile_settings = {
-        "inputs": [trtorch.Input([1, 3, 5, 5])],
+        "inputs": [torchtrt.Input([1, 3, 5, 5])],
         "enabled_precisions": {torch.float32}
     }
 
-    trt_ts_module = trtorch.compile(scripted_model, compile_settings)
+    trt_ts_module = torchtrt.compile(scripted_model, compile_settings)
     torch.jit.save(trt_ts_module, 'conv_gelu.jit')
 
     norm_model = Norm().eval().cuda()
     norm_ts_module = torch.jit.script(norm_model)
-    norm_trt_ts = trtorch.compile(norm_ts_module, compile_settings)
+    norm_trt_ts = torchtrt.compile(norm_ts_module, compile_settings)
     torch.jit.save(norm_trt_ts, 'norm.jit')
     print("Generated Torchscript-TRT models.")
 

py/torch_tensorrt/__init__.py

@@ -2,7 +2,7 @@
 import sys
 
 if sys.version_info < (3,):
-    raise Exception("Python 2 has reached end-of-life and is not supported by TRTorch")
+    raise Exception("Python 2 has reached end-of-life and is not supported by Torch-TensorRT")
 
 import ctypes
 import torch

py/torch_tensorrt/csrc/tensorrt_backend.cpp

@@ -66,7 +66,7 @@ c10::IValue preprocess(
   for (auto it = method_compile_spec.begin(), end = method_compile_spec.end(); it != end; ++it) {
     TORCHTRT_CHECK(
         core::CheckMethodOperatorSupport(mod, it->key().toStringRef()),
-        "Method " << it->key().toStringRef() << "cannot be compiled by TRTorch");
+        "Method " << it->key().toStringRef() << "cannot be compiled by Torch-TensorRT");
   }
   return mod._ivalue();
 };

py/torch_tensorrt/logging.py

@@ -53,7 +53,7 @@ def get_reportable_log_level() -> Level:
     """Get the level required for a message to be printed in the log
 
     Returns:
-        trtorch.logging.Level: The enum representing the level required to print
+        torch_tensorrt.logging.Level: The enum representing the level required to print
     """
     return Level(_get_reportable_log_level())
 
@@ -62,7 +62,7 @@ def set_reportable_log_level(level: Level):
     """Set the level required for a message to be printed to the log
 
     Args:
-        level (trtorch.logging.Level): The enum representing the level required to print
+        level (torch_tensorrt.logging.Level): The enum representing the level required to print
     """
     _set_reportable_log_level(Level._to_internal_level(level))
 
@@ -92,7 +92,7 @@ def log(level: Level, msg: str):
     will only get printed out if Level > reportable_log_level
 
     Args:
-        level (trtorch.logging.Level): Severity of the message
+        level (torch_tensorrt.logging.Level): Severity of the message
         msg (str): Actual message text
     """
     _log(Level._to_internal_level(level), msg)

tests/modules/hub_rnn_transformer.py

@@ -13,7 +13,7 @@ namespace tests {
 namespace util {
 
 std::vector<torch::jit::IValue> EvaluateGraph(const torch::jit::Block* b, std::vector<torch::jit::IValue> inputs) {
-  LOG_DEBUG("Running TRTorch Version");
+  LOG_DEBUG("Running Torch-TensorRT Version");
 
   core::conversion::ConversionCtx* ctx = new core::conversion::ConversionCtx({});