+ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ DataType
+
+
+ ¶
+
+ + Supported Data Types that can be used with TensorRT engines +
++ This class is compatable with c10::DataTypes (but will check for TRT support) so there should not be a reason that you need to use this type explictly. +
++ Public Types +
+
+ Value
+
+
+ ¶
+
+ + Underlying enum class to support the + + + DataType + + + Class +
++ In the case that you need to use the + + + DataType + + + class itself, interface using this enum vs. normal instatination +
++ ex. + + + torch_tensorrt::DataType + + + type = + + + DataType::kFloat + + + ; +
++ + Values: + +
+
+ kFloat
+
+
+ ¶
+
+ + FP32. +
+
+ kHalf
+
+
+ ¶
+
+ + FP16. +
+
+ kChar
+
+
+ ¶
+
+ + INT8. +
+
+ kInt
+
+
+ ¶
+
+ + INT. +
+
+ kBool
+
+
+ ¶
+
+ + Bool. +
+
+ kUnknown
+
+
+ ¶
+
+ + Sentinel value. +
++ Public Functions +
+
+ DataType
+
+
+ (
+
+
+ )
+
+ = default
+
+ ¶
+
+ + Construct a new Data Type object. +
+
+ DataType
+
+
+ (
+
+
+ Value
+
+
+ t
+
+
+ )
+
+
+ ¶
+
+ + + + DataType + + + constructor from enum. +
+
+ DataType
+
+
+ (
+
+ c10::ScalarType
+
+ t
+
+
+ )
+
+
+ ¶
+
+ + Construct a new Data Type object from torch type enums. +
++
+
+
+
+ t
+
+
+ :
+
+ operator Value
+
+
+ (
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Get the enum value of the + + + DataType + + + object. +
++
++ Value +
+
+ operator bool
+
+
+ (
+
+
+ )
+
+ = delete
+
+ ¶
+
+
+ operator==
+
+
+ (
+
+
+ DataType
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + DataType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator==
+
+
+ (
+
+
+ DataType
+
+ ::
+
+ Value
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + DataType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator!=
+
+
+ (
+
+
+ DataType
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + DataType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator!=
+
+
+ (
+
+
+ DataType
+
+ ::
+
+ Value
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + DataType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ Defined in + + + File torch_tensorrt.h + + +
++ This class is a nested type of + + + Struct Device + + + . +
+
+ torch_tensorrt::
+
+ Device
+
+
+ ::
+
+
+
+ DeviceType
+
+
+ ¶
+
+ + Supported + + + Device + + + Types that can be used with TensorRT engines +
++ This class is compatable with c10::DeviceTypes (but will check for TRT support) but the only applicable value is at::kCUDA, which maps to + + + DeviceType::kGPU + + +
++ To use the + + + DataType + + + class itself, interface using the enum vs. normal instatination +
++ ex. torch_tensorrt::DeviceType type = + + + DeviceType::kGPU + + + ; +
++ Public Types +
+
+ Value
+
+
+ ¶
+
+ + Underlying enum class to support the + + + DeviceType + + + Class +
++ In the case that you need to use the + + + DeviceType + + + class itself, interface using this enum vs. normal instatination +
++ ex. torch_tensorrt::DeviceType type = + + + DeviceType::kGPU + + + ; +
++ + Values: + +
+
+ kGPU
+
+
+ ¶
+
+ + Target GPU to run engine. +
+
+ kDLA
+
+
+ ¶
+
+ + Target DLA to run engine. +
++ Public Functions +
+
+ DeviceType
+
+
+ (
+
+
+ )
+
+ = default
+
+ ¶
+
+ + Construct a new + + + Device + + + Type object. +
+
+ DeviceType
+
+
+ (
+
+
+ Value
+
+
+ t
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Device + + + Type object from internal enum. +
+
+ DeviceType
+
+
+ (
+
+ c10::DeviceType
+
+ t
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Device + + + Type object from torch device enums Note: The only valid value is torch::kCUDA (torch::kCPU is not supported) +
++
+
+
+
+ t
+
+
+ :
+
+ operator Value
+
+
+ (
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Get the internal value from the + + + Device + + + object. +
++
++ Value +
+
+ operator bool
+
+
+ (
+
+
+ )
+
+ = delete
+
+ ¶
+
+
+ operator==
+
+
+ (
+
+
+ DeviceType
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparison operator for + + + DeviceType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator!=
+
+
+ (
+
+
+ DeviceType
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparison operator for + + + DeviceType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ TensorFormat
+
+
+ ¶
+
+ + + + TensorFormat + + + is an enum class which defines the memeory layout used to store Tensor Data. +
++ Public Types +
+
+ Value
+
+
+ ¶
+
+ + Underlying enum class to support the + + + TensorFormat + + + Class +
++ In the case that you need to use the + + + TensorFormat + + + class itself, interface using this enum vs. normal instatination +
++ ex. + + + torch_tensorrt::TensorFormat + + + type = + + + TensorFormat::kContiguous + + + ; +
++ + Values: + +
+
+ kContiguous
+
+
+ ¶
+
+ + Contiguous / NCHW / Linear. +
+
+ kChannelsLast
+
+
+ ¶
+
+ + Channel Last / NHWC. +
+
+ kUnknown
+
+
+ ¶
+
+ + Sentinel value. +
++ Public Functions +
+
+ TensorFormat
+
+
+ (
+
+
+ )
+
+ = default
+
+ ¶
+
+ + Construct a new + + + TensorFormat + + + object. +
+
+ TensorFormat
+
+
+ (
+
+
+ Value
+
+
+ t
+
+
+ )
+
+
+ ¶
+
+ + + + TensorFormat + + + constructor from enum. +
+
+ TensorFormat
+
+
+ (
+
+ at::MemoryFormat
+
+ t
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + TensorFormat + + + object from torch type enums. +
++
+
+
+
+ t
+
+
+ :
+
+ operator Value
+
+
+ (
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Get the enum value of the + + + TensorFormat + + + object. +
++
++ Value +
+
+ operator bool
+
+
+ (
+
+
+ )
+
+ = delete
+
+ ¶
+
+
+ operator==
+
+
+ (
+
+
+ TensorFormat
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + TensorFormat + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator==
+
+
+ (
+
+
+ TensorFormat
+
+ ::
+
+ Value
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + TensorFormat + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator!=
+
+
+ (
+
+
+ TensorFormat
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + TensorFormat + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator!=
+
+
+ (
+
+
+ TensorFormat
+
+ ::
+
+ Value
+
+
+ other
+
+
+ )
+
+
+ const
+
+
+ ¶
+
+ + Comparision operator for + + + TensorFormat + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ Defined in + + + File ptq.h + + +
+
+
+
+ private
+
+
+ Algorithm
+
+
+
+ Algorithm
+
+ >
+
+ torch_tensorrt::ptq
+
+ ::
+
+
+
+ Int8CacheCalibrator
+
+ :
+
+ private
+
+
+ Algorithm
+
+
+ ¶
+
+ + Generic + + + Int8Calibrator + + + implementation based on a specified TensorRT calibration algorithm that only reads from a calibration file. +
++
+
+
+
+ Algorithm
+
+
+ : class nvinfer1::IInt8Calibrator (Default: nvinfer1::IInt8EntropyCalibrator2) - Algorithm to use
+
+ Public Functions +
+
+ Int8CacheCalibrator
+
+
+ (
+
+
+ const
+
+ std::string &
+
+ cache_file_path
+
+
+ )
+
+
+ ¶
+
+ + Construct a new Int 8 Cache Calibrator object. +
++
+
+
+
+ cache_file_path
+
+
+ :
+
+ getBatchSize
+
+
+ (
+
+
+ )
+
+
+ const
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Get the Batch Size for the next batch (always 1 due to issues with TRT and explicit batch) +
++
++ int +
+
+ getBatch
+
+
+ (
+
+ void *
+
+ bindings
+
+ [],
+
+ const
+
+ char *
+
+ names
+
+ [], int
+
+ nbBindings
+
+
+ )
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Get the next Batch. +
++ Not used always returns false +
++
++ false +
+
+
+
+ bindings
+
+
+ : void*[] - An array of binding pointers (fed in from TensorRT calibrator), these buffers should be filed with batch data for each input
+
+
+
+ names
+
+
+ : const char*[] - Names of bindings
+
+
+
+ nbBindings
+
+
+ : int - Number of bindings
+
+ readCalibrationCache
+
+
+ (
+
+ size_t &
+
+ length
+
+
+ )
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Read calibration cache. +
++ How to read from the calibration cache, only enabled if use_cache is set +
++
++ const void* - Pointer to cache data +
+
+
+
+ length
+
+
+ :
+
+ writeCalibrationCache
+
+
+ (
+
+
+ const
+
+ void *
+
+ cache
+
+ , size_t
+
+ length
+
+
+ )
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Write calibration cache. +
++ Write a the calibration cache provided by TensorRT to a specified file +
++
+
+
+
+ cache
+
+
+ : const void* - cache data
+
+
+
+ length
+
+
+ : size_t - length of cache
+
+ operator nvinfer1::IInt8Calibrator*
+
+
+ (
+
+
+ )
+
+
+ ¶
+
+ + operator to cast to nvinfer1::IInt8Calibrator* +
++ Convience function to convert to a IInt8Calibrator* to easily be assigned to the ptq_calibrator field in CompileSpec +
++
++ nvinfer1::IInt8Calibrator* +
++ Defined in + + + File ptq.h + + +
+
+
+
+ private
+
+
+ Algorithm
+
+
+
+ Algorithm
+
+ , typename
+
+ DataLoaderUniquePtr
+
+ >
+
+ torch_tensorrt::ptq
+
+ ::
+
+
+
+ Int8Calibrator
+
+ :
+
+ private
+
+
+ Algorithm
+
+
+ ¶
+
+ + Generic + + + Int8Calibrator + + + implementation based on a specified TensorRT calibration algorithm and a LibTorch DataLoader. +
++
+
+
+
+ Algorithm
+
+
+ : class nvinfer1::IInt8Calibrator (Default: nvinfer1::IInt8EntropyCalibrator2) - Algorithm to use
+
+
+
+ DataLoaderUniquePtr
+
+
+ : std::unique_ptr<torch::data::DataLoader> - DataLoader type
+
+ Public Functions +
+
+ Int8Calibrator
+
+
+ (
+
+
+ DataLoaderUniquePtr
+
+
+ dataloader
+
+ ,
+
+ const
+
+ std::string &
+
+ cache_file_path
+
+ , bool
+
+ use_cache
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Int8Calibrator + + + object. +
++ Using the provided DataLoader, construct a calibrator that can be used for PTQ with Torch-TensorRT +
++
+
+
+
+ dataloader
+
+
+ : std::unqiue_ptr<torch::data::DataLoader> - A unique pointer to the DataLoader, should be what is returned from the make_data_loader factory
+
+
+
+ cache_file_path
+
+
+ : const std::string& - A path to store / find the calibration cache
+
+
+
+ use_cache
+
+
+ : : bool - Whether to use the cache (if it exists)
+
+ getBatchSize
+
+
+ (
+
+
+ )
+
+
+ const
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Get the Batch Size for the next batch (always 1 due to issues with TRT and explicit batch) +
++
++ int +
+
+ getBatch
+
+
+ (
+
+ void *
+
+ bindings
+
+ [],
+
+ const
+
+ char *
+
+ names
+
+ [], int
+
+ nbBindings
+
+
+ )
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Get the next Batch. +
++
++ true - There is a new batch for the calibrator to consume +
++ false - There is not a new batch for the calibrator to consume +
+
+
+
+ bindings
+
+
+ : void*[] - An array of binding pointers (fed in from TensorRT calibrator), these buffers should be filed with batch data for each input
+
+
+
+ names
+
+
+ : const char*[] - Names of bindings
+
+
+
+ nbBindings
+
+
+ : int - Number of bindings
+
+ readCalibrationCache
+
+
+ (
+
+ size_t &
+
+ length
+
+
+ )
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Read calibration cache. +
++ How to read from the calibration cache, only enabled if use_cache is set +
++
++ const void* - Pointer to cache data +
+
+
+
+ length
+
+
+ :
+
+ writeCalibrationCache
+
+
+ (
+
+
+ const
+
+ void *
+
+ cache
+
+ , size_t
+
+ length
+
+
+ )
+
+
+ noexcept
+
+
+ override
+
+
+ ¶
+
+ + Write calibration cache. +
++ Write a the calibration cache provided by TensorRT to a specified file +
++
+
+
+
+ cache
+
+
+ : const void* - cache data
+
+
+
+ length
+
+
+ : size_t - length of cache
+
+ operator nvinfer1::IInt8Calibrator*
+
+
+ (
+
+
+ )
+
+
+ ¶
+
+ + operator to cast to nvinfer1::IInt8Calibrator* +
++ Convience function to convert to a IInt8Calibrator* to easily be assigned to the ptq_calibrator field in CompileSpec +
++
++ nvinfer1::IInt8Calibrator* +
++ Defined in + + + File macros.h + + +
+
+ STR
+
+
+ (
+
+
+ x
+
+
+ )
+
+
+ ¶
+
+ + Defined in + + + File macros.h + + +
+
+ TORCH_TENSORRT_PATCH_VERSION
+
+
+ ¶
+
+ + Defined in + + + File macros.h + + +
+
+ TORCH_TENSORRT_MAJOR_VERSION
+
+
+ ¶
+
+ + Defined in + + + File macros.h + + +
+
+ TORCH_TENSORRT_MINOR_VERSION
+
+
+ ¶
+
+ + Defined in + + + File macros.h + + +
+
+ TORCHTRT_API
+
+
+ ¶
+
+ + Defined in + + + File macros.h + + +
+
+ XSTR
+
+
+ (
+
+
+ x
+
+
+ )
+
+
+ ¶
+
+ + Defined in + + + File macros.h + + +
+
+ TORCHTRT_HIDDEN
+
+
+ ¶
+
+ + Defined in + + + File macros.h + + +
+
+ TORCH_TENSORRT_VERSION
+
+
+ ¶
+
+
+ ↰
+
+
+ Parent directory
+
+
+ (
+
+
+ cpp
+
+
+ )
+
+
+ Directory path:
+
+
+
+ cpp/include
+
+
+
+ ↰
+
+
+ Parent directory
+
+
+ (
+
+
+ cpp/include
+
+
+ )
+
+
+ Directory path:
+
+
+
+ cpp/include/torch_tensorrt
+
+
+
+ Defined in + + + File logging.h + + +
+
+ torch_tensorrt::logging
+
+ ::
+
+
+
+ Level
+
+
+ ¶
+
+ + Emum for setting message severity +
++ + Values: + +
+
+ kINTERNAL_ERROR
+
+
+ ¶
+
+ + Only print messages for internal errors. +
+
+ kERROR
+
+
+ ¶
+
+ + Print all internal errors and errors (default) +
+
+ kWARNING
+
+
+ ¶
+
+ + Print warnings and errors. +
+
+ kINFO
+
+
+ ¶
+
+ + Print all info, warnings and errors. +
+
+ kDEBUG
+
+
+ ¶
+
+ + Print all debug info, info, warnings and errors. +
+
+ kGRAPH
+
+
+ ¶
+
+ + Print everything including the intermediate graphs of the lowering phase. +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ EngineCapability
+
+
+ ¶
+
+ + Emum for selecting engine capability +
++ + Values: + +
+
+ kSTANDARD
+
+
+ ¶
+
+
+ kSAFETY
+
+
+ ¶
+
+
+ kDLA_STANDALONE
+
+
+ ¶
+
+
+ ↰
+
+
+ Parent directory
+
+
+ (
+
+
+ cpp/include/torch_tensorrt
+
+
+ )
+
+ Contents +
+
+
+ Definition (
+
+
+ cpp/include/torch_tensorrt/logging.h
+
+
+ )
+
+
+ + Includes + +
++ + Included By + +
++ + Namespaces + +
++ + Enums + +
++ + Functions + +
+
+
+ cpp/include/torch_tensorrt/logging.h
+
+
+ )
+
+ ¶
+
+
+
+
+ string
+
+
+
+
+
+ torch_tensorrt/macros.h
+
+
+ (
+
+
+ File macros.h
+
+
+ )
+
+ + + Function torch_tensorrt::logging::get_is_colored_output_on + + +
++ + + Function torch_tensorrt::logging::get_logging_prefix + + +
++ + + Function torch_tensorrt::logging::get_reportable_log_level + + +
++ + + Function torch_tensorrt::logging::set_is_colored_output_on + + +
++ + + Function torch_tensorrt::logging::set_logging_prefix + + +
++ + + Function torch_tensorrt::logging::set_reportable_log_level + + +
+
+ ↰
+
+
+ Parent directory
+
+
+ (
+
+
+ cpp/include/torch_tensorrt
+
+
+ )
+
+ Contents +
+
+
+ Definition (
+
+
+ cpp/include/torch_tensorrt/macros.h
+
+
+ )
+
+
+ + Included By + +
++ + Namespaces + +
++ + Defines + +
+
+
+ cpp/include/torch_tensorrt/macros.h
+
+
+ )
+
+ ¶
+
+
+ ↰
+
+
+ Parent directory
+
+
+ (
+
+
+ cpp/include/torch_tensorrt
+
+
+ )
+
+ Contents +
+
+
+ Definition (
+
+
+ cpp/include/torch_tensorrt/ptq.h
+
+
+ )
+
+
+ + Includes + +
++ + Namespaces + +
++ + Classes + +
++ + Functions + +
+
+
+ cpp/include/torch_tensorrt/ptq.h
+
+
+ )
+
+ ¶
+
+
+
+
+ NvInfer.h
+
+
+
+
+
+ fstream
+
+
+
+
+
+ iostream
+
+
+
+
+
+ iterator
+
+
+
+
+
+ memory
+
+
+
+
+
+ sstream
+
+
+
+
+
+ string
+
+
+
+
+
+ torch/torch.h
+
+
+
+
+
+ torch_tensorrt/logging.h
+
+
+ (
+
+
+ File logging.h
+
+
+ )
+
+
+
+ vector
+
+
+
+ ↰
+
+
+ Parent directory
+
+
+ (
+
+
+ cpp/include/torch_tensorrt
+
+
+ )
+
+ Contents +
+
+
+ Definition (
+
+
+ cpp/include/torch_tensorrt/torch_tensorrt.h
+
+
+ )
+
+
+ + Includes + +
++ + Namespaces + +
++ + Classes + +
++ + Enums + +
++ + Functions + +
+
+
+ cpp/include/torch_tensorrt/torch_tensorrt.h
+
+
+ )
+
+ ¶
+
+
+
+
+ cuda_runtime.h
+
+
+
+
+
+ iostream
+
+
+
+
+
+ memory
+
+
+
+
+
+ set
+
+
+
+
+
+ string
+
+
+
+
+
+ torch_tensorrt/macros.h
+
+
+ (
+
+
+ File macros.h
+
+
+ )
+
+
+
+ vector
+
+
+
+ + + Function torch_tensorrt::torchscript::check_method_operator_support + + +
++ + + Function torch_tensorrt::torchscript::convert_method_to_trt_engine + + +
++ + + Function torch_tensorrt::torchscript::embed_engine_in_new_module + + +
++ Defined in + + + File logging.h + + +
+
+ torch_tensorrt::logging
+
+ ::
+
+
+
+ get_logging_prefix
+
+
+ (
+
+
+ )
+
+
+ ¶
+
+ + Defined in + + + File logging.h + + +
++ Defined in + + + File logging.h + + +
+
+ torch_tensorrt::logging
+
+ ::
+
+
+
+ get_is_colored_output_on
+
+
+ (
+
+
+ )
+
+
+ ¶
+
+ + Is colored output enabled? +
++
++ TORCHTRT_API get_is_colored_output_on +
++ Defined in + + + File logging.h + + +
+
+ torch_tensorrt::logging
+
+ ::
+
+
+
+ set_reportable_log_level
+
+
+ (
+
+
+ Level
+
+
+ lvl
+
+
+ )
+
+
+ ¶
+
+ + Sets the level that logging information needs to be to be added to the log. +
++
+
+
+
+ lvl
+
+
+ : torch_tensorrt::logging::Level - Level that messages need to be at or above to be added to the log
+
+ Defined in + + + File logging.h + + +
+
+ torch_tensorrt::logging
+
+ ::
+
+
+
+ log
+
+
+ (
+
+
+ Level
+
+
+ lvl
+
+ , std::string
+
+ msg
+
+
+ )
+
+
+ ¶
+
+ + Adds a message to the global log. +
++
+
+
+
+ lvl
+
+
+ : torch_tensorrt::logging::Level - Severity of the message
+
+
+
+ msg
+
+
+ : std::string - Message to be logged
+
+ Defined in + + + File logging.h + + +
+
+ torch_tensorrt::logging
+
+ ::
+
+
+
+ set_is_colored_output_on
+
+
+ (
+
+ bool
+
+ colored_output_on
+
+
+ )
+
+
+ ¶
+
+ + Sets if logging prefix will be colored (helpful when debugging but not always supported by terminal) +
++
+
+
+
+ colored_output_on
+
+
+ : bool - If the output will be colored or not
+
+ Defined in + + + File logging.h + + +
+
+ torch_tensorrt::logging
+
+ ::
+
+
+
+ set_logging_prefix
+
+
+ (
+
+ std::string
+
+ prefix
+
+
+ )
+
+
+ ¶
+
+ + Defined in + + + File ptq.h + + +
+
+ Algorithm
+
+ = nvinfer1::IInt8EntropyCalibrator2>
+
+ torch_tensorrt::ptq
+
+ ::
+
+
+
+ make_int8_cache_calibrator
+
+
+ (
+
+
+ const
+
+ std::string &
+
+ cache_file_path
+
+
+ )
+
+
+ ¶
+
+ + A factory to build a post training quantization calibrator from a torch dataloader that only uses the calibration cache. +
++ Creates a calibrator to use for post training quantization which reads from a previously created calibration cache, therefore you can have a calibration cache generating program that requires a dataloader and a dataset, then save the cache to use later in a different program that needs to calibrate from scratch and not have the dataset dependency. However, the network should also be recalibrated if its structure changes, or the input data set changes, and it is the responsibility of the application to ensure this. +
++ By default the returned calibrator uses TensorRT Entropy v2 algorithm to perform calibration. This is recommended for feed forward networks You can override the algorithm selection (such as to use the MinMax Calibrator recomended for NLP tasks) by calling make_int8_calibrator with the calibrator class as a template parameter. +
++ e.g. torch_tensorrt::ptq::make_int8_cache_calibrator<nvinfer1::IInt8MinMaxCalibrator>(calibration_cache_file); +
++ Int8CacheCalibrator<Algorithm> +
+
+
+
+ Algorithm
+
+
+ : class nvinfer1::IInt8Calibrator (Default: nvinfer1::IInt8EntropyCalibrator2) - Algorithm to use
+
+
+
+ cache_file_path
+
+
+ : const std::string& - Path to read/write calibration cache
+
+ Defined in + + + File ptq.h + + +
+
+ Algorithm
+
+ = nvinfer1::IInt8EntropyCalibrator2, typename
+
+ DataLoader
+
+ >
+
+ torch_tensorrt::ptq
+
+ ::
+
+
+
+ make_int8_calibrator
+
+
+ (
+
+
+ DataLoader
+
+
+ dataloader
+
+ ,
+
+ const
+
+ std::string &
+
+ cache_file_path
+
+ , bool
+
+ use_cache
+
+
+ )
+
+
+ ¶
+
+ + A factory to build a post training quantization calibrator from a torch dataloader. +
++ Creates a calibrator to use for post training quantization. By default the returned calibrator uses TensorRT Entropy v2 algorithm to perform calibration. This is recommended for feed forward networks. You can override the algorithm selection (such as to use the MinMax Calibrator recomended for NLP tasks) by calling make_int8_calibrator with the calibrator class as a template parameter. +
+
+ e.g.
+
+
+ torch_tensorrt::ptq::make_int8_calibrator<nvinfer1::IInt8MinMaxCalibrator>(std::move(calibration_dataloader),
+
+
+ calibration_cache_file,
+
+
+ use_cache);
+
+
+
+ Int8Calibrator<Algorithm, DataLoader> +
+
+
+
+ Algorithm
+
+
+ : class nvinfer1::IInt8Calibrator (Default: nvinfer1::IInt8EntropyCalibrator2) - Algorithm to use
+
+
+
+ DataLoader
+
+
+ : std::unique_ptr<torch::data::DataLoader> - DataLoader type
+
+
+
+ dataloader
+
+
+ : std::unique_ptr<torch::data::DataLoader> - DataLoader containing data
+
+
+
+ cache_file_path
+
+
+ : const std::string& - Path to read/write calibration cache
+
+
+
+ use_cache
+
+
+ : bool - use calibration cache
+
+ Defined in + + + File ptq.h + + +
+
+ Algorithm
+
+ = nvinfer1::IInt8EntropyCalibrator2, typename
+
+ DataLoader
+
+ >
+
+ torch_tensorrt::ptq
+
+ ::
+
+
+
+ make_int8_calibrator
+
+
+ (
+
+
+ DataLoader
+
+
+ dataloader
+
+ ,
+
+ const
+
+ std::string &
+
+ cache_file_path
+
+ , bool
+
+ use_cache
+
+
+ )
+
+ + A factory to build a post training quantization calibrator from a torch dataloader. +
++ Creates a calibrator to use for post training quantization. By default the returned calibrator uses TensorRT Entropy v2 algorithm to perform calibration. This is recommended for feed forward networks. You can override the algorithm selection (such as to use the MinMax Calibrator recomended for NLP tasks) by calling make_int8_calibrator with the calibrator class as a template parameter. +
+
+ e.g.
+
+
+ torch_tensorrt::ptq::make_int8_calibrator<nvinfer1::IInt8MinMaxCalibrator>(std::move(calibration_dataloader),
+
+
+ calibration_cache_file,
+
+
+ use_cache);
+
+
+
+ Int8Calibrator<Algorithm, DataLoader> +
+
+
+
+ Algorithm
+
+
+ : class nvinfer1::IInt8Calibrator (Default: nvinfer1::IInt8EntropyCalibrator2) - Algorithm to use
+
+
+
+ DataLoader
+
+
+ : std::unique_ptr<torch::data::DataLoader> - DataLoader type
+
+
+
+ dataloader
+
+
+ : std::unique_ptr<torch::data::DataLoader> - DataLoader containing data
+
+
+
+ cache_file_path
+
+
+ : const std::string& - Path to read/write calibration cache
+
+
+
+ use_cache
+
+
+ : bool - use calibration cache
+
+ Defined in + + + File ptq.h + + +
+
+ Algorithm
+
+ = nvinfer1::IInt8EntropyCalibrator2>
+
+ torch_tensorrt::ptq
+
+ ::
+
+
+
+ make_int8_cache_calibrator
+
+
+ (
+
+
+ const
+
+ std::string &
+
+ cache_file_path
+
+
+ )
+
+ + A factory to build a post training quantization calibrator from a torch dataloader that only uses the calibration cache. +
++ Creates a calibrator to use for post training quantization which reads from a previously created calibration cache, therefore you can have a calibration cache generating program that requires a dataloader and a dataset, then save the cache to use later in a different program that needs to calibrate from scratch and not have the dataset dependency. However, the network should also be recalibrated if its structure changes, or the input data set changes, and it is the responsibility of the application to ensure this. +
++ By default the returned calibrator uses TensorRT Entropy v2 algorithm to perform calibration. This is recommended for feed forward networks You can override the algorithm selection (such as to use the MinMax Calibrator recomended for NLP tasks) by calling make_int8_calibrator with the calibrator class as a template parameter. +
++ e.g. torch_tensorrt::ptq::make_int8_cache_calibrator<nvinfer1::IInt8MinMaxCalibrator>(calibration_cache_file); +
++ Int8CacheCalibrator<Algorithm> +
+
+
+
+ Algorithm
+
+
+ : class nvinfer1::IInt8Calibrator (Default: nvinfer1::IInt8EntropyCalibrator2) - Algorithm to use
+
+
+
+ cache_file_path
+
+
+ : const std::string& - Path to read/write calibration cache
+
+ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt::torchscript
+
+ ::
+
+
+
+ check_method_operator_support
+
+
+ (
+
+
+ const
+
+ torch::jit::Module &
+
+ module
+
+ , std::string
+
+ method_name
+
+
+ )
+
+
+ ¶
+
+ + Check to see if a module is fully supported by the compiler. +
++
++ Takes a module and a method name and checks if the method graph contains purely convertable operators +
+
+
+
+ module
+
+
+ : torch::jit::script::Module - Existing TorchScript module
+
+
+
+ method_name
+
+
+ : std::string - Name of method to compile
+
+ Will print out a list of unsupported operators if the graph is unsupported +
++
++ bool: Method is supported by Torch-TensorRT.TorchScript +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt::torchscript
+
+ ::
+
+
+
+ compile
+
+
+ (
+
+
+ const
+
+ torch::jit::Module &
+
+ module
+
+ ,
+
+ CompileSpec
+
+
+ info
+
+
+ )
+
+
+ ¶
+
+ + Compile a TorchScript module for NVIDIA GPUs using TensorRT. +
++
++ Takes a existing TorchScript module and a set of settings to configure the compiler and will convert methods to JIT Graphs which call equivalent TensorRT engines +
+
+
+
+ module
+
+
+ : torch::jit::Module - Existing TorchScript module
+
+
+
+ info
+
+
+ : torch_tensorrt::CompileSpec - Compilation settings
+
+ Converts specifically the forward method of a TorchScript Module +
++
++ : A new module trageting a TensorRT engine +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt::torchscript
+
+ ::
+
+
+
+ embed_engine_in_new_module
+
+
+ (
+
+
+ const
+
+ std::string &
+
+ engine
+
+ ,
+
+ Device
+
+
+ device
+
+
+ )
+
+
+ ¶
+
+ + Take a previously created TensorRT engine and embed it in in a TorchScript module. +
++
++ Takes a pre-built serialized TensorRT engine and embeds it in a TorchScript module. Registers execution of the engine as the forward method of the module Forward is defined as: forward(Tensor[]) -> Tensor[] +
+
+
+
+ engine
+
+
+ : std::string - Pre-built serialized TensorRT engine
+
+
+
+ device
+
+
+ : CompileSepc::Device -
+
+
+ Device
+
+
+ information
+
+ TensorRT bindings must have names with the following format: +
++ [symbol].[index in input / output array] ex. +
++ [x.0, x.1, x.2] -> [y.0] +
++
++ : A new module targeting a TensorRT engine +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ get_build_info
+
+
+ (
+
+
+ )
+
+
+ ¶
+
+ + Get the build information for the library including the dependency versions. +
++
++ std::string +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ set_device
+
+
+ (
+
+
+ const
+
+ int
+
+ gpu_id
+
+
+ )
+
+
+ ¶
+
+ + Set gpu device id. +
++
+
+
+
+ gpu_id
+
+
+ : Sets gpu id using cudaSetDevice
+
+ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ dump_build_info
+
+
+ (
+
+
+ )
+
+
+ ¶
+
+ + Dump the version information for Torch-TensorRT including base libtorch and TensorRT versions to stdout. +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt::torchscript
+
+ ::
+
+
+
+ convert_method_to_trt_engine
+
+
+ (
+
+
+ const
+
+ torch::jit::Module &
+
+ module
+
+ , std::string
+
+ method_name
+
+ ,
+
+ CompileSpec
+
+
+ info
+
+
+ )
+
+
+ ¶
+
+ + Compile a TorchScript method for NVIDIA GPUs using TensorRT. +
++
++ Takes a existing TorchScript module and a set of settings to configure the compiler and will convert selected method to a serialized TensorRT engine which can be run with TensorRT +
+
+
+
+ module
+
+
+ : torch::jit::Module - Existing TorchScript module
+
+
+
+ method_name
+
+
+ : std::string - Name of method to compile
+
+
+
+ info
+
+
+ : torch_tensorrt::CompileSpec - Compilation settings
+
+
++ : std::string: Serialized TensorRT engine equivilant to the method graph +
++ Contents +
++ + Namespaces + +
++ + Classes + +
++ + Enums + +
++ + Functions + +
++ Contents +
++ + Enums + +
++ + Functions + +
++ + + Function torch_tensorrt::logging::get_is_colored_output_on + + +
++ + + Function torch_tensorrt::logging::get_logging_prefix + + +
++ + + Function torch_tensorrt::logging::get_reportable_log_level + + +
++ + + Function torch_tensorrt::logging::set_is_colored_output_on + + +
++ + + Function torch_tensorrt::logging::set_logging_prefix + + +
++ + + Function torch_tensorrt::logging::set_reportable_log_level + + +
++ Contents +
++ + Classes + +
++ + Functions + +
++ Contents +
++ + Classes + +
++ + Functions + +
+
+ ↰
+
+
+ Return to documentation for file
+
+
+ (
+
+
+ cpp/include/torch_tensorrt/logging.h
+
+
+ )
+
/*
+ * Copyright (c) NVIDIA Corporation.
+ * All rights reserved.
+ *
+ * This library is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+#pragma once
+
+#include <string>
+#include "torch_tensorrt/macros.h"
+
+namespace torch_tensorrt {
+namespace logging {
+enum Level {
+ kINTERNAL_ERROR,
+ kERROR,
+ kWARNING,
+ kINFO,
+ kDEBUG,
+ kGRAPH,
+};
+
+// Are these ones necessary for the user?
+TORCHTRT_API std::string get_logging_prefix();
+TORCHTRT_API void set_logging_prefix(std::string prefix);
+
+TORCHTRT_API void set_reportable_log_level(Level lvl);
+
+TORCHTRT_API void set_is_colored_output_on(bool colored_output_on);
+
+TORCHTRT_API Level get_reportable_log_level();
+
+TORCHTRT_API bool get_is_colored_output_on();
+
+// Dont know if we want this?
+TORCHTRT_API void log(Level lvl, std::string msg);
+} // namespace logging
+} // namespace torch_tensorrt
+
+
+ ↰
+
+
+ Return to documentation for file
+
+
+ (
+
+
+ cpp/include/torch_tensorrt/macros.h
+
+
+ )
+
/*
+ * Copyright (c) NVIDIA Corporation.
+ * All rights reserved.
+ *
+ * This library is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+#pragma once
+
+#if defined(__GNUC__)
+#define TORCHTRT_API __attribute__((__visibility__("default")))
+#define TORCHTRT_HIDDEN __attribute__((__visibility__("hidden")))
+#else
+#define TORCHTRT_API
+#define TORCHTRT_HIDDEN
+#endif // defined(__GNUC__)
+
+// Does this need to be gaurded or something?
+#define XSTR(x) #x
+#define STR(x) XSTR(x)
+
+#define TORCH_TENSORRT_MAJOR_VERSION 1
+#define TORCH_TENSORRT_MINOR_VERSION 1
+#define TORCH_TENSORRT_PATCH_VERSION 0
+#define TORCH_TENSORRT_VERSION \
+ STR(TORCH_TENSORRT_MAJOR_VERSION) \
+ "." STR(TORCH_TENSORRT_MINOR_VERSION) "." STR(TORCH_TENSORRT_PATCH_VERSION)
+
+// Setup namespace aliases for ease of use
+namespace torch_tensorrt {
+namespace torchscript {}
+namespace ts = torchscript;
+} // namespace torch_tensorrt
+namespace torchtrt = torch_tensorrt;
+
+
+ ↰
+
+
+ Return to documentation for file
+
+
+ (
+
+
+ cpp/include/torch_tensorrt/ptq.h
+
+
+ )
+
/*
+ * Copyright (c) NVIDIA Corporation.
+ * All rights reserved.
+ *
+ * This library is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+#pragma once
+
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "NvInfer.h"
+#include "torch/torch.h"
+#include "torch_tensorrt/logging.h"
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace nvinfer1 {
+class IInt8Calibrator;
+class IInt8EntropyCalibrator2;
+} // namespace nvinfer1
+
+namespace torch_tensorrt {
+namespace ptq {
+bool get_batch_impl(void* bindings[], const char* names[], int nbBindings, torch::Tensor& data);
+}
+} // namespace torch_tensorrt
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+namespace torch_tensorrt {
+namespace ptq {
+
+template <typename Algorithm, typename DataLoaderUniquePtr>
+class Int8Calibrator : Algorithm {
+ using DataLoader = typename DataLoaderUniquePtr::element_type;
+ using Batch = typename DataLoader::super::BatchType;
+
+ public:
+ Int8Calibrator(DataLoaderUniquePtr dataloader, const std::string& cache_file_path, bool use_cache)
+ : dataloader_(dataloader.get()), cache_file_path_(cache_file_path), use_cache_(use_cache) {
+ for (auto batch : *dataloader_) {
+ batched_data_.push_back(batch.data);
+ }
+ it_ = batched_data_.begin();
+ }
+
+ int getBatchSize() const noexcept override {
+ // HACK: Torch-TensorRT only uses explict batch sizing, INT8 Calibrator does not
+ // work when reporting the batch size here and having explicity batching.
+ // So we just report batch size 1 (warnings will still be printed out).
+ return 1;
+ // return static_cast<int>(dataloader_->options().batch_size);
+ }
+
+ bool getBatch(void* bindings[], const char* names[], int nbBindings) noexcept override {
+ if (it_ != batched_data_.end()) {
+ auto status = get_batch_impl(bindings, names, nbBindings, *it_);
+ it_ = ++it_;
+ return status;
+ } else {
+ // Reset iterator if incase calibrator is going to be used again
+ it_ = batched_data_.begin();
+ return false;
+ }
+ }
+
+ const void* readCalibrationCache(size_t& length) noexcept override {
+ if (use_cache_) {
+ std::stringstream ss;
+ ss << "Reading Calibration Cache from " << cache_file_path_;
+ logging::log(logging::Level::kINFO, ss.str());
+
+ cache_.clear();
+ std::ifstream input(cache_file_path_, std::ios::binary);
+ input >> std::noskipws;
+ if (input.good()) {
+ std::copy(std::istream_iterator<char>(input), std::istream_iterator<char>(), std::back_inserter(cache_));
+ logging::log(logging::Level::kDEBUG, "Cache read");
+ }
+ length = cache_.size();
+ return length ? cache_.data() : nullptr;
+ }
+ return nullptr;
+ }
+
+ void writeCalibrationCache(const void* cache, size_t length) noexcept override {
+ std::ofstream cache_file(cache_file_path_, std::ios::binary);
+ cache_file.write(reinterpret_cast<const char*>(cache), length);
+ std::stringstream ss;
+ ss << "Saved Calibration Cache to " << cache_file_path_;
+ logging::log(logging::Level::kINFO, ss.str());
+ }
+
+ operator nvinfer1::IInt8Calibrator*() {
+ return reinterpret_cast<nvinfer1::IInt8Calibrator*>(this);
+ }
+
+ private:
+ DataLoader* dataloader_;
+ const std::string& cache_file_path_;
+ size_t cache_size_ = 0;
+ bool use_cache_;
+ std::vector<char> cache_;
+ std::vector<torch::Tensor> batched_data_;
+ std::vector<torch::Tensor>::iterator it_;
+};
+
+template <typename Algorithm>
+class Int8CacheCalibrator : Algorithm {
+ public:
+ Int8CacheCalibrator(const std::string& cache_file_path) : cache_file_path_(cache_file_path) {}
+
+ int getBatchSize() const noexcept override {
+ // HACK: Torch-TensorRT only uses explict batch sizing, INT8 Calibrator does not
+ // work when reporting the batch size here and having explicity batching.
+ // So we just report batch size 1 (warnings will still be printed out).
+ return 1;
+ }
+
+ bool getBatch(void* bindings[], const char* names[], int nbBindings) noexcept override {
+ return false;
+ }
+
+ const void* readCalibrationCache(size_t& length) noexcept override {
+ std::stringstream ss;
+ ss << "Reading Calibration Cache from " << cache_file_path_;
+ logging::log(logging::Level::kINFO, ss.str());
+
+ cache_.clear();
+ std::ifstream input(cache_file_path_, std::ios::binary);
+ input >> std::noskipws;
+ if (input.good()) {
+ std::copy(std::istream_iterator<char>(input), std::istream_iterator<char>(), std::back_inserter(cache_));
+ logging::log(logging::Level::kDEBUG, "Cache read");
+ }
+ length = cache_.size();
+ return length ? cache_.data() : nullptr;
+ }
+
+ void writeCalibrationCache(const void* cache, size_t length) noexcept override {
+ std::ofstream cache_file(cache_file_path_, std::ios::binary);
+ cache_file.write(reinterpret_cast<const char*>(cache), length);
+ std::stringstream ss;
+ ss << "Saved Calibration Cache to " << cache_file_path_;
+ logging::log(logging::Level::kINFO, ss.str());
+ }
+
+ operator nvinfer1::IInt8Calibrator*() {
+ return reinterpret_cast<nvinfer1::IInt8Calibrator*>(this);
+ }
+
+ private:
+ const std::string& cache_file_path_;
+ size_t cache_size_ = 0;
+ std::vector<char> cache_;
+};
+
+template <typename Algorithm = nvinfer1::IInt8EntropyCalibrator2, typename DataLoader>
+TORCHTRT_API inline Int8Calibrator<Algorithm, DataLoader> make_int8_calibrator(
+ DataLoader dataloader,
+ const std::string& cache_file_path,
+ bool use_cache) {
+ return Int8Calibrator<Algorithm, DataLoader>(std::move(dataloader), cache_file_path, use_cache);
+}
+
+template <typename Algorithm = nvinfer1::IInt8EntropyCalibrator2>
+TORCHTRT_API inline Int8CacheCalibrator<Algorithm> make_int8_cache_calibrator(const std::string& cache_file_path) {
+ return Int8CacheCalibrator<Algorithm>(cache_file_path);
+}
+
+} // namespace ptq
+} // namespace torch_tensorrt
+
+
+ ↰
+
+
+ Return to documentation for file
+
+
+ (
+
+
+ cpp/include/torch_tensorrt/torch_tensorrt.h
+
+
+ )
+
/*
+ * Copyright (c) NVIDIA Corporation.
+ * All rights reserved.
+ *
+ * This library is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cuda_runtime.h>
+#include <iostream>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+// Just include the .h?
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace torch {
+namespace jit {
+struct Graph;
+struct Module;
+} // namespace jit
+} // namespace torch
+
+namespace c10 {
+enum class DeviceType : int8_t;
+enum class ScalarType : int8_t;
+template <class>
+class ArrayRef;
+} // namespace c10
+
+namespace nvinfer1 {
+class IInt8Calibrator;
+}
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+#include "torch_tensorrt/macros.h"
+namespace torch_tensorrt {
+class TORCHTRT_API DataType {
+ public:
+ enum Value : int8_t {
+ kFloat,
+ kHalf,
+ kChar,
+ kInt,
+ kBool,
+ kUnknown
+ };
+
+ DataType() = default;
+ constexpr DataType(Value t) : value(t) {}
+ DataType(c10::ScalarType t);
+ operator Value() const {
+ return value;
+ }
+ explicit operator bool() = delete;
+ constexpr bool operator==(DataType other) const {
+ return value == other.value;
+ }
+ constexpr bool operator==(DataType::Value other) const {
+ return value == other;
+ }
+ constexpr bool operator!=(DataType other) const {
+ return value != other.value;
+ }
+ constexpr bool operator!=(DataType::Value other) const {
+ return value != other;
+ }
+
+ private:
+ friend std::ostream& operator<<(std::ostream& os, const DataType& dtype);
+ Value value;
+};
+
+struct Device {
+ class DeviceType {
+ public:
+ enum Value : int8_t {
+ kGPU,
+ kDLA,
+ };
+
+ DeviceType() = default;
+ constexpr DeviceType(Value t) : value(t) {}
+ DeviceType(c10::DeviceType t);
+ operator Value() const {
+ return value;
+ }
+ explicit operator bool() = delete;
+ constexpr bool operator==(DeviceType other) const {
+ return value == other.value;
+ }
+ constexpr bool operator!=(DeviceType other) const {
+ return value != other.value;
+ }
+
+ private:
+ Value value;
+ };
+
+ DeviceType device_type;
+
+ /*
+ * Target gpu id
+ */
+ int64_t gpu_id;
+
+ /*
+ * When using DLA core on NVIDIA AGX platforms gpu_id should be set as Xavier device
+ */
+ int64_t dla_core;
+
+ bool allow_gpu_fallback;
+
+ Device() : device_type(DeviceType::kGPU), gpu_id(0), dla_core(0), allow_gpu_fallback(false) {}
+};
+
+enum class EngineCapability : int8_t {
+ kSTANDARD,
+ kSAFETY,
+ kDLA_STANDALONE,
+};
+
+class TORCHTRT_API TensorFormat {
+ public:
+ enum Value : int8_t {
+ kContiguous,
+ kChannelsLast,
+ kUnknown,
+ };
+
+ TensorFormat() = default;
+ constexpr TensorFormat(Value t) : value(t) {}
+ TensorFormat(at::MemoryFormat t);
+ operator Value() const {
+ return value;
+ }
+ explicit operator bool() = delete;
+ constexpr bool operator==(TensorFormat other) const {
+ return value == other.value;
+ }
+ constexpr bool operator==(TensorFormat::Value other) const {
+ return value == other;
+ }
+ constexpr bool operator!=(TensorFormat other) const {
+ return value != other.value;
+ }
+ constexpr bool operator!=(TensorFormat::Value other) const {
+ return value != other;
+ }
+
+ private:
+ friend std::ostream& operator<<(std::ostream& os, const TensorFormat& format);
+ Value value;
+};
+
+struct TORCHTRT_API Input {
+ std::vector<int64_t> min_shape;
+ std::vector<int64_t> opt_shape;
+ std::vector<int64_t> max_shape;
+ std::vector<int64_t> shape;
+ DataType dtype;
+ TensorFormat format;
+
+ Input(std::vector<int64_t> shape, TensorFormat format = TensorFormat::kContiguous);
+
+ Input(std::vector<int64_t> shape, DataType dtype, TensorFormat format = TensorFormat::kContiguous);
+
+ Input(c10::ArrayRef<int64_t> shape, TensorFormat format = TensorFormat::kContiguous);
+
+ Input(c10::ArrayRef<int64_t> shape, DataType dtype, TensorFormat format = TensorFormat::kContiguous);
+
+ Input(
+ std::vector<int64_t> min_shape,
+ std::vector<int64_t> opt_shape,
+ std::vector<int64_t> max_shape,
+ TensorFormat format = TensorFormat::kContiguous);
+
+ Input(
+ std::vector<int64_t> min_shape,
+ std::vector<int64_t> opt_shape,
+ std::vector<int64_t> max_shape,
+ DataType dtype,
+ TensorFormat format = TensorFormat::kContiguous);
+
+ Input(
+ c10::ArrayRef<int64_t> min_shape,
+ c10::ArrayRef<int64_t> opt_shape,
+ c10::ArrayRef<int64_t> max_shape,
+ TensorFormat format = TensorFormat::kContiguous);
+
+ Input(
+ c10::ArrayRef<int64_t> min_shape,
+ c10::ArrayRef<int64_t> opt_shape,
+ c10::ArrayRef<int64_t> max_shape,
+ DataType dtype,
+ TensorFormat format = TensorFormat::kContiguous);
+
+ Input(at::Tensor tensor);
+
+ private:
+ friend std::ostream& operator<<(std::ostream& os, const Input& input);
+ bool input_is_dynamic;
+};
+
+TORCHTRT_API std::string get_build_info();
+
+TORCHTRT_API void dump_build_info();
+
+TORCHTRT_API void set_device(const int gpu_id);
+
+namespace torchscript {
+struct TORCHTRT_API CompileSpec {
+ CompileSpec(std::vector<std::vector<int64_t>> fixed_sizes);
+
+ CompileSpec(std::vector<c10::ArrayRef<int64_t>> fixed_sizes);
+
+ CompileSpec(std::vector<Input> inputs) : inputs(std::move(inputs)) {}
+
+ // Defaults should reflect TensorRT defaults for BuilderConfig
+
+ std::vector<Input> inputs;
+
+ std::set<DataType> enabled_precisions = {DataType::kFloat};
+
+ bool disable_tf32 = false;
+
+ bool sparse_weights = false;
+
+ bool refit = false;
+
+ bool debug = false;
+
+ bool truncate_long_and_double = false;
+
+ Device device;
+
+ EngineCapability capability = EngineCapability::kSTANDARD;
+
+ uint64_t num_min_timing_iters = 2;
+ uint64_t num_avg_timing_iters = 1;
+
+ uint64_t workspace_size = 0;
+
+ nvinfer1::IInt8Calibrator* ptq_calibrator = nullptr;
+
+ bool require_full_compilation = false;
+
+ uint64_t min_block_size = 3;
+
+ std::vector<std::string> torch_executed_ops;
+
+ std::vector<std::string> torch_executed_modules;
+};
+
+TORCHTRT_API bool check_method_operator_support(const torch::jit::Module& module, std::string method_name);
+
+TORCHTRT_API torch::jit::Module compile(const torch::jit::Module& module, CompileSpec info);
+
+TORCHTRT_API std::string convert_method_to_trt_engine(
+ const torch::jit::Module& module,
+ std::string method_name,
+ CompileSpec info);
+
+TORCHTRT_API torch::jit::Module embed_engine_in_new_module(const std::string& engine, Device device);
+} // namespace torchscript
+} // namespace torch_tensorrt
+
+ + Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ Device
+
+
+ ¶
+
+ + Setting data structure for Target device. +
++ Public Functions +
+
+ Device
+
+
+ (
+
+
+ )
+
+
+ ¶
+
+ + Constructor for + + + Device + + + structure +
++ Public Members +
+
+ device_type
+
+
+ ¶
+
+ + Setting data structure for device This struct will hold Target device related parameters such as device_type, gpu_id, dla_core. +
+
+ gpu_id
+
+
+ ¶
+
+
+ dla_core
+
+
+ ¶
+
+
+ allow_gpu_fallback
+
+
+ ¶
+
+ + (Only used when targeting DLA (device)) Lets engine run layers on GPU if they are not supported on DLA +
+
+ DeviceType
+
+ + Supported + + + Device + + + Types that can be used with TensorRT engines +
++ This class is compatable with c10::DeviceTypes (but will check for TRT support) but the only applicable value is at::kCUDA, which maps to + + + DeviceType::kGPU + + +
++ To use the + + + DataType + + + class itself, interface using the enum vs. normal instatination +
++ ex. torch_tensorrt::DeviceType type = + + + DeviceType::kGPU + + + ; +
++ Public Types +
+
+ Value
+
+ + Underlying enum class to support the + + + DeviceType + + + Class +
++ In the case that you need to use the + + + DeviceType + + + class itself, interface using this enum vs. normal instatination +
++ ex. torch_tensorrt::DeviceType type = + + + DeviceType::kGPU + + + ; +
++ + Values: + +
+
+ kGPU
+
+ + Target GPU to run engine. +
+
+ kDLA
+
+ + Target DLA to run engine. +
++ Public Functions +
+
+ DeviceType
+
+
+ (
+
+
+ )
+
+ = default
+ + Construct a new + + + Device + + + Type object. +
+
+ DeviceType
+
+
+ (
+
+
+ Value
+
+
+ t
+
+
+ )
+
+ + Construct a new + + + Device + + + Type object from internal enum. +
+
+ DeviceType
+
+
+ (
+
+ c10::DeviceType
+
+ t
+
+
+ )
+
+ + Construct a new + + + Device + + + Type object from torch device enums Note: The only valid value is torch::kCUDA (torch::kCPU is not supported) +
++
+
+
+
+ t
+
+
+ :
+
+ operator Value
+
+
+ (
+
+
+ )
+
+
+ const
+
+ + Get the internal value from the + + + Device + + + object. +
++
++ Value +
+
+ operator bool
+
+
+ (
+
+
+ )
+
+ = delete
+
+ operator==
+
+
+ (
+
+
+ DeviceType
+
+
+ other
+
+
+ )
+
+
+ const
+
+ + Comparison operator for + + + DeviceType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ operator!=
+
+
+ (
+
+
+ DeviceType
+
+
+ other
+
+
+ )
+
+
+ const
+
+ + Comparison operator for + + + DeviceType + + + . +
++
++ true +
++ false +
+
+
+
+ other
+
+
+ :
+
+ Defined in + + + File torch_tensorrt.h + + +
++ Warning +
++ doxygenstruct: Cannot find class “torch_tensorrt::GraphInputs” in doxygen xml output for project “Torch-TensorRT” from directory: ./_tmp/xml +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt
+
+ ::
+
+
+
+ Input
+
+
+ ¶
+
+ + A struct to hold an input range (used by TensorRT Optimization profile) +
++ This struct can either hold a single vector representing an input shape, signifying a static input shape or a set of three input shapes representing the min, optiminal and max input shapes allowed for the engine. +
++ Public Functions +
+
+ Input
+
+
+ (
+
+ std::vector<int64_t>
+
+ shape
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object for static input size from vector, optional arguments allow the user to configure expected input shape tensor format. dtype (Expected data type for the input) defaults to PyTorch / traditional TRT convection (FP32 for FP32 only, FP16 for FP32 and FP16, FP32 for Int8) +
++
+
+
+
+ shape
+
+
+ :
+
+
+ Input
+
+
+ tensor shape
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ std::vector<int64_t>
+
+ shape
+
+ ,
+
+ DataType
+
+
+ dtype
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object for static input size from vector, optional arguments allow the user to configure expected input shape tensor format. +
++
+
+
+
+ shape
+
+
+ :
+
+
+ Input
+
+
+ tensor shape
+
+
+
+ dtype
+
+
+ : Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ c10::ArrayRef<int64_t>
+
+ shape
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object for static input size from c10::ArrayRef (the type produced by tensor.sizes()), vector, optional arguments allow the user to configure expected input shape tensor format dtype (Expected data type for the input) defaults to PyTorch / traditional TRT convection (FP32 for FP32 only, FP16 for FP32 and FP16, FP32 for Int8) +
++
+
+
+
+ shape
+
+
+ :
+
+
+ Input
+
+
+ tensor shape
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ c10::ArrayRef<int64_t>
+
+ shape
+
+ ,
+
+ DataType
+
+
+ dtype
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object for static input size from c10::ArrayRef (the type produced by tensor.sizes()), vector, optional arguments allow the user to configure expected input shape tensor format. +
++
+
+
+
+ shape
+
+
+ :
+
+
+ Input
+
+
+ tensor shape
+
+
+
+ dtype
+
+
+ : Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ std::vector<int64_t>
+
+ min_shape
+
+ , std::vector<int64_t>
+
+ opt_shape
+
+ , std::vector<int64_t>
+
+ max_shape
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object dynamic input size from c10::ArrayRef (the type produced by tensor.sizes()) for min, opt, and max supported sizes. dtype (Expected data type for the input) defaults to PyTorch / traditional TRT convection (FP32 for FP32 only, FP16 for FP32 and FP16, FP32 for Int8) +
++
+
+
+
+ min_shape
+
+
+ : Minimum shape for input tensor
+
+
+
+ opt_shape
+
+
+ : Target optimization shape for input tensor
+
+
+
+ max_shape
+
+
+ : Maximum acceptible shape for input tensor
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ std::vector<int64_t>
+
+ min_shape
+
+ , std::vector<int64_t>
+
+ opt_shape
+
+ , std::vector<int64_t>
+
+ max_shape
+
+ ,
+
+ DataType
+
+
+ dtype
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object for a dynamic input size from vectors for minimum shape, optimal shape, and max shape supported sizes optional arguments allow the user to configure expected input shape tensor format. +
++
+
+
+
+ min_shape
+
+
+ : Minimum shape for input tensor
+
+
+
+ opt_shape
+
+
+ : Target optimization shape for input tensor
+
+
+
+ max_shape
+
+
+ : Maximum acceptible shape for input tensor
+
+
+
+ dtype
+
+
+ : Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ c10::ArrayRef<int64_t>
+
+ min_shape
+
+ , c10::ArrayRef<int64_t>
+
+ opt_shape
+
+ , c10::ArrayRef<int64_t>
+
+ max_shape
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object dynamic input size from c10::ArrayRef (the type produced by tensor.sizes()) for min, opt, and max supported sizes. dtype (Expected data type for the input) defaults to PyTorch / traditional TRT convection (FP32 for FP32 only, FP16 for FP32 and FP16, FP32 for Int8) +
++
+
+
+
+ min_shape
+
+
+ : Minimum shape for input tensor
+
+
+
+ opt_shape
+
+
+ : Target optimization shape for input tensor
+
+
+
+ max_shape
+
+
+ : Maximum acceptible shape for input tensor
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ c10::ArrayRef<int64_t>
+
+ min_shape
+
+ , c10::ArrayRef<int64_t>
+
+ opt_shape
+
+ , c10::ArrayRef<int64_t>
+
+ max_shape
+
+ ,
+
+ DataType
+
+
+ dtype
+
+ ,
+
+ TensorFormat
+
+
+ format
+
+ =
+
+ TensorFormat
+
+ ::
+
+ kContiguous
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object dynamic input size from c10::ArrayRef (the type produced by tensor.sizes()) for min, opt, and max supported sizes. +
++
+
+
+
+ min_shape
+
+
+ : Minimum shape for input tensor
+
+
+
+ opt_shape
+
+
+ : Target optimization shape for input tensor
+
+
+
+ max_shape
+
+
+ : Maximum acceptible shape for input tensor
+
+
+
+ dtype
+
+
+ : Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+
+
+
+ format
+
+
+ : Expected tensor format for the input (Defaults to contiguous)
+
+ Input
+
+
+ (
+
+ at::Tensor
+
+ tensor
+
+
+ )
+
+
+ ¶
+
+ + Construct a new + + + Input + + + spec object using a torch tensor as an example The tensor’s shape, type and layout inform the spec’s values. +
++ Note: You cannot set dynamic shape through this method, you must use an alternative constructor +
++
+
+
+
+ tensor
+
+
+ : Reference tensor to set shape, type and layout
+
+ Public Members +
+
+ min_shape
+
+
+ ¶
+
+ + Minimum acceptable input size into the engine. +
+
+ opt_shape
+
+
+ ¶
+
+ + Optimal input size into the engine (size optimized for given kernels accept any size in min max range) +
+
+ max_shape
+
+
+ ¶
+
+ + Maximum acceptable input size into the engine. +
+
+ shape
+
+
+ ¶
+
+ + + + Input + + + shape to be fed to TensorRT, in the event of a dynamic shape, -1’s will hold the place of variable dimensions +
+
+ dtype
+
+
+ ¶
+
+ + Expected data type for the input. +
+
+ format
+
+
+ ¶
+
+ + Expected tensor format for the input. +
++ Defined in + + + File torch_tensorrt.h + + +
+
+ torch_tensorrt::torchscript
+
+ ::
+
+
+
+ CompileSpec
+
+
+ ¶
+
+ + Settings data structure for Torch-TensorRT TorchScript compilation +
++ Public Functions +
+
+ CompileSpec
+
+
+ (
+
+ std::vector<std::vector<int64_t>>
+
+ fixed_sizes
+
+
+ )
+
+
+ ¶
+
+ + Construct a new Compile Spec object Convienence constructor to set fixed input size from vectors describing size of input tensors. Each entry in the vector represents a input and should be provided in call order. +
++ This constructor should be use as a convience in the case that all inputs are static sized and you are okay with default input dtype and formats (FP32 for FP32 and INT8 weights, FP16 for FP16 weights, contiguous) +
++
+
+
+
+ fixed_sizes
+
+
+ :
+
+ CompileSpec
+
+
+ (
+
+ std::vector<c10::ArrayRef<int64_t>>
+
+ fixed_sizes
+
+
+ )
+
+
+ ¶
+
+ + Construct a new Extra Info object Convienence constructor to set fixed input size from c10::ArrayRef’s (the output of tensor.sizes()) describing size of input tensors. Each entry in the vector represents a input and should be provided in call order. +
++ This constructor should be use as a convience in the case that all inputs are static sized and you are okay with default input dtype and formats (FP32 for FP32 and INT8 weights, FP16 for FP16 weights, contiguous) +
++
+
+
+
+ fixed_sizes
+
+
+ :
+
+ CompileSpec
+
+
+ (
+
+ std::vector<
+
+ Input
+
+ >
+
+ inputs
+
+
+ )
+
+
+ ¶
+
+ + Construct a new Extra Info object from input ranges. Each entry in the vector represents a input and should be provided in call order. +
++ Use this constructor to define inputs with dynamic shape, specific input types or tensor formats +
++
+
+
+
+ inputs
+
+
+ :
+
+ Public Members +
+
+ inputs
+
+
+ ¶
+
+ + Specifications for inputs to the engine, can either be a single size or a range defined by min, opt and max sizes Users can also specify expected input type as well as tensor memory format. +
++ Order in vector should match call order for the function +
+
+ enabled_precisions
+
+ = {
+
+ DataType
+
+ ::
+
+ kFloat
+
+ }
+
+ ¶
+
+ + The set of precisions TensorRT is allowed to use for kernels during compilation. +
+
+ disable_tf32
+
+ = false
+
+ ¶
+
+ + Prevent Float32 layers from using TF32 data format +
++ TF32 computes inner products by rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas. This is the behavior of FP32 layers by default. +
+
+ sparse_weights
+
+ = false
+
+ ¶
+
+ + Enable sparsity for weights of conv and FC layers +
+
+ refit
+
+ = false
+
+ ¶
+
+ + Build a refitable engine +
+
+ debug
+
+ = false
+
+ ¶
+
+ + Build a debugable engine +
+
+ truncate_long_and_double
+
+ = false
+
+ ¶
+
+ + Truncate long/double type to int/float type +
+
+ device
+
+
+ ¶
+
+ + Target + + + Device + + +
+
+ capability
+
+ =
+
+ EngineCapability
+
+ ::
+
+ kSTANDARD
+
+
+ ¶
+
+ + Sets the restrictions for the engine (CUDA Safety) +
+
+ num_min_timing_iters
+
+ = 2
+
+ ¶
+
+ + Number of minimization timing iterations used to select kernels +
+
+ num_avg_timing_iters
+
+ = 1
+
+ ¶
+
+ + Number of averaging timing iterations used to select kernels +
+
+ workspace_size
+
+ = 0
+
+ ¶
+
+ + Maximum size of workspace given to TensorRT +
+
+ ptq_calibrator
+
+ = nullptr
+
+ ¶
+
+ + Calibration dataloaders for each input for post training quantizatiom +
+
+ require_full_compilation
+
+ = false
+
+ ¶
+
+ + Require the full module be compiled to TensorRT instead of potentially running unsupported operations in PyTorch +
+
+ min_block_size
+
+ = 3
+
+ ¶
+
+ + Minimum number of contiguous supported operators to compile a subgraph to TensorRT +
+
+ torch_executed_ops
+
+
+ ¶
+
+
+ List of aten operators that must be run in PyTorch. An error will be thrown if this list is not empty but
+
+
+ require_full_compilation
+
+
+ is True
+
+ torch_executed_modules
+
+
+ ¶
+
+
+ List of modules that must be run in PyTorch. An error will be thrown if this list is not empty but
+
+
+ require_full_compilation
+
+
+ is True
+
+
+ cpp/include/torch_tensorrt/logging.h
+
+
+ )
+
+
+
+
+ cpp/include/torch_tensorrt/macros.h
+
+
+ )
+
+
+
+
+ cpp/include/torch_tensorrt/ptq.h
+
+
+ )
+
+
+
+
+ cpp/include/torch_tensorrt/torch_tensorrt.h
+
+
+ )
+
+
+ To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+import torch
+
+from torch_tensorrt import _enums
+from torch_tensorrt import logging
+from torch_tensorrt import _C
+
+import warnings
+
+
+[docs]class Device(object):
+ """
+ Defines a device that can be used to specify target devices for engines
+
+ Attributes:
+ device_type (torch_tensorrt.DeviceType): Target device type (GPU or DLA). Set implicitly based on if dla_core is specified.
+ gpu_id (int): Device ID for target GPU
+ dla_core (int): Core ID for target DLA core
+ allow_gpu_fallback (bool): Whether falling back to GPU if DLA cannot support an op should be allowed
+ """
+
+ device_type = None #: (torch_tensorrt.DeviceType): Target device type (GPU or DLA). Set implicitly based on if dla_core is specified.
+ gpu_id = -1 #: (int) Device ID for target GPU
+ dla_core = -1 #: (int) Core ID for target DLA core
+ allow_gpu_fallback = False #: (bool) Whether falling back to GPU if DLA cannot support an op should be allowed
+
+[docs] def __init__(self, *args, **kwargs):
+ """__init__ Method for torch_tensorrt.Device
+
+ Device accepts one of a few construction patterns
+
+ Args:
+ spec (str): String with device spec e.g. "dla:0" for dla, core_id 0
+
+ Keyword Arguments:
+ gpu_id (int): ID of target GPU (will get overrided if dla_core is specified to the GPU managing DLA). If specified, no positional arguments should be provided
+ dla_core (int): ID of target DLA core. If specified, no positional arguments should be provided.
+ allow_gpu_fallback (bool): Allow TensorRT to schedule operations on GPU if they are not supported on DLA (ignored if device type is not DLA)
+
+ Examples:
+ - Device("gpu:1")
+ - Device("cuda:1")
+ - Device("dla:0", allow_gpu_fallback=True)
+ - Device(gpu_id=0, dla_core=0, allow_gpu_fallback=True)
+ - Device(dla_core=0, allow_gpu_fallback=True)
+ - Device(gpu_id=1)
+ """
+ if len(args) == 1:
+ if not isinstance(args[0], str):
+ raise TypeError(
+ "When specifying Device through positional argument, argument must be str"
+ )
+ else:
+ (self.device_type, id) = Device._parse_device_str(args[0])
+ if self.device_type == _enums.DeviceType.GPU:
+ self.gpu_id = id
+ else:
+ self.dla_core = id
+ self.gpu_id = 0
+ logging.log(
+ logging.Level.Warning,
+ "Setting GPU id to 0 for device because device 0 manages DLA on Xavier",
+ )
+
+ elif len(args) == 0:
+ if "gpu_id" in kwargs or "dla_core" in kwargs:
+ if "dla_core" in kwargs:
+ self.device_type = _enums.DeviceType.DLA
+ self.dla_core = kwargs["dla_core"]
+ if "gpu_id" in kwargs:
+ self.gpu_id = kwargs["gpu_id"]
+ else:
+ self.gpu_id = 0
+ logging.log(
+ logging.Level.Warning,
+ "Setting GPU id to 0 for device because device 0 manages DLA on Xavier",
+ )
+ else:
+ self.gpu_id = kwargs["gpu_id"]
+ self.device_type = _enums.DeviceType.GPU
+ else:
+ raise ValueError(
+ "Either gpu_id or dla_core or both must be defined if no string with device specs is provided as an arg"
+ )
+
+ else:
+ raise ValueError(
+ "Unexpected number of positional arguments for class Device \n Found {} arguments, expected either zero or a single positional arguments".format(
+ len(args)
+ )
+ )
+
+ if "allow_gpu_fallback" in kwargs:
+ if not isinstance(kwargs["allow_gpu_fallback"], bool):
+ raise TypeError("allow_gpu_fallback must be a bool")
+ self.allow_gpu_fallback = kwargs["allow_gpu_fallback"]
+
+ def __str__(self) -> str:
+ return (
+ "Device(type={}, gpu_id={}".format(self.device_type, self.gpu_id) + ")"
+ if self.device_type == _enums.DeviceType.GPU
+ else ", dla_core={}, allow_gpu_fallback={}".format(
+ self.dla_core, self.allow_gpu_fallback
+ )
+ )
+
+ def _to_internal(self) -> _C.Device:
+ internal_dev = _C.Device()
+ internal_dev.device_type = self.device_type
+ internal_dev.gpu_id = self.gpu_id
+ internal_dev.dla_core = self.dla_core
+ internal_dev.allow_gpu_fallback = self.allow_gpu_fallback
+ return internal_dev
+
+ @classmethod
+ def _from_torch_device(cls, torch_dev: torch.device):
+ if torch_dev.type != "cuda":
+ raise ValueError('Torch Device specs must have type "cuda"')
+ gpu_id = torch_dev.index
+ return cls(gpu_id=gpu_id)
+
+ @classmethod
+ def _current_device(cls):
+ try:
+ dev = _C._get_current_device()
+ except RuntimeError:
+ logging.log(logging.Level.Error, "Cannot get current device")
+ return None
+ return cls(gpu_id=dev.gpu_id)
+
+ @staticmethod
+ def _parse_device_str(s):
+ s = s.lower()
+ spec = s.split(":")
+ if spec[0] == "gpu" or spec[0] == "cuda":
+ return (_enums.DeviceType.GPU, int(spec[1]))
+ elif spec[0] == "dla":
+ return (_enums.DeviceType.DLA, int(spec[1]))
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from enum import Enum
+from typing import List, Dict, Any
+
+import torch
+
+from torch_tensorrt import _enums
+from torch_tensorrt import _C
+
+
+[docs]class Input(object):
+ """
+ Defines an input to a module in terms of expected shape, data type and tensor format.
+
+ Attributes:
+ shape_mode (torch_tensorrt.Input._ShapeMode): Is input statically or dynamically shaped
+ shape (Tuple or Dict): Either a single Tuple or a dict of tuples defining the input shape.
+ Static shaped inputs will have a single tuple. Dynamic inputs will have a dict of the form
+ ``{
+ "min_shape": Tuple,
+ "opt_shape": Tuple,
+ "max_shape": Tuple
+ }``
+ dtype (torch_tensorrt.dtype): The expected data type of the input tensor (default: torch_tensorrt.dtype.float32)
+ format (torch_tensorrt.TensorFormat): The expected format of the input tensor (default: torch_tensorrt.TensorFormat.NCHW)
+ """
+
+ class _ShapeMode(Enum):
+ STATIC = 0
+ DYNAMIC = 1
+
+ shape_mode = None #: (torch_tensorrt.Input._ShapeMode): Is input statically or dynamically shaped
+ shape = None #: (Tuple or Dict): Either a single Tuple or a dict of tuples defining the input shape. Static shaped inputs will have a single tuple. Dynamic inputs will have a dict of the form ``{ "min_shape": Tuple, "opt_shape": Tuple, "max_shape": Tuple }``
+ dtype = (
+ _enums.dtype.unknown
+ ) #: The expected data type of the input tensor (default: torch_tensorrt.dtype.float32)
+ _explicit_set_dtype = False
+ format = (
+ _enums.TensorFormat.contiguous
+ ) #: The expected format of the input tensor (default: torch_tensorrt.TensorFormat.NCHW)
+
+[docs] def __init__(self, *args, **kwargs):
+ """__init__ Method for torch_tensorrt.Input
+
+ Input accepts one of a few construction patterns
+
+ Args:
+ shape (Tuple or List, optional): Static shape of input tensor
+
+ Keyword Arguments:
+ shape (Tuple or List, optional): Static shape of input tensor
+ min_shape (Tuple or List, optional): Min size of input tensor's shape range
+ Note: All three of min_shape, opt_shape, max_shape must be provided, there must be no positional arguments, shape must not be defined and implictly this sets Input's shape_mode to DYNAMIC
+ opt_shape (Tuple or List, optional): Opt size of input tensor's shape range
+ Note: All three of min_shape, opt_shape, max_shape must be provided, there must be no positional arguments, shape must not be defined and implictly this sets Input's shape_mode to DYNAMIC
+ max_shape (Tuple or List, optional): Max size of input tensor's shape range
+ Note: All three of min_shape, opt_shape, max_shape must be provided, there must be no positional arguments, shape must not be defined and implictly this sets Input's shape_mode to DYNAMIC
+ dtype (torch.dtype or torch_tensorrt.dtype): Expected data type for input tensor (default: torch_tensorrt.dtype.float32)
+ format (torch.memory_format or torch_tensorrt.TensorFormat): The expected format of the input tensor (default: torch_tensorrt.TensorFormat.NCHW)
+
+ Examples:
+ - Input([1,3,32,32], dtype=torch.float32, format=torch.channel_last)
+ - Input(shape=(1,3,32,32), dtype=torch_tensorrt.dtype.int32, format=torch_tensorrt.TensorFormat.NCHW)
+ - Input(min_shape=(1,3,32,32), opt_shape=[2,3,32,32], max_shape=(3,3,32,32)) #Implicitly dtype=torch_tensorrt.dtype.float32, format=torch_tensorrt.TensorFormat.NCHW
+ """
+ if len(args) == 1:
+ if not Input._supported_input_size_type(args[0]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(args[0]))
+ )
+ if any(k in kwargs for k in ["min_shape", "opt_shape", "max_shape"]):
+ raise ValueError(
+ "Found that both shape (as a positional argument), and one or more of min_shape, opt_shape, max_shape were specified\nclass Input expects that only either shape or all three of min_shape, opt_shape, max_shape are defined"
+ )
+ self.shape = tuple(args[0])
+ self.shape_mode = Input._ShapeMode.STATIC
+
+ elif len(args) == 0:
+ if not ("shape" in kwargs) and not (
+ all(k in kwargs for k in ["min_shape", "opt_shape", "max_shape"])
+ ):
+ raise ValueError(
+ "Missing required arguments for class Input\nEither shape or all three of min_shape, opt_shape, max_shape must be defined"
+ )
+ elif ("shape" in kwargs) and all(
+ k in kwargs for k in ["min_shape", "opt_shape", "max_shape"]
+ ):
+ raise ValueError(
+ "Found that both shape, and one or more of min_shape, opt_shape, max_shape were specified\nclass Input expects that only either shape or all three of min_shape, opt_shape, max_shape are defined"
+ )
+
+ if "shape" in kwargs:
+ if not Input._supported_input_size_type(kwargs["shape"]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(kwargs["shape"]))
+ )
+ self.shape = tuple(kwargs["shape"])
+ self.shape_mode = Input._ShapeMode.STATIC
+ else:
+ if not Input._supported_input_size_type(kwargs["min_shape"]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(kwargs["min_shape"]))
+ + " for min_shape"
+ )
+ if not Input._supported_input_size_type(kwargs["opt_shape"]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(kwargs["opt_shape"]))
+ + " for opt_shape"
+ )
+ if not Input._supported_input_size_type(kwargs["max_shape"]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(kwargs["max_shape"]))
+ + " for max_shape"
+ )
+
+ self.shape = {
+ "min_shape": tuple(kwargs["min_shape"]),
+ "opt_shape": tuple(kwargs["opt_shape"]),
+ "max_shape": tuple(kwargs["max_shape"]),
+ }
+ self.shape_mode = Input._ShapeMode.DYNAMIC
+
+ else:
+ raise ValueError(
+ "Unexpected number of positional arguments for class Input \n Found {} arguments, expected either zero or a single positional arguments".format(
+ len(args)
+ )
+ )
+
+ if "dtype" in kwargs:
+ self.dtype = Input._parse_dtype(kwargs["dtype"])
+ self._explicit_set_dtype = True
+
+ if "format" in kwargs:
+ self.format = Input._parse_format(kwargs["format"])
+
+ def __str__(self) -> str:
+ if self.shape_mode == Input._ShapeMode.STATIC:
+ return "Input(shape={}, dtype={}, format={})".format(
+ self.shape, str(self.dtype), str(self.format)
+ )
+ elif self.shape_mode == Input._ShapeMode.DYNAMIC:
+ return "Input(min_shape={}, opt_shape={}, max_shape={}, dtype={}, format={})".format(
+ self.shape["min_shape"],
+ self.shape["opt_shape"],
+ self.shape["max_shape"],
+ str(self.dtype),
+ str(self.format),
+ )
+ else:
+ raise RuntimeError("Unknown input shape mode")
+
+ def _to_internal(self) -> _C.Input:
+ internal_in = _C.Input()
+ if self.shape_mode == Input._ShapeMode.DYNAMIC:
+ if not Input._supported_input_size_type(self.shape["min_shape"]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(self.shape["min_shape"]))
+ + " for min_shape"
+ )
+ else:
+ internal_in.min = self.shape["min_shape"]
+
+ if not Input._supported_input_size_type(self.shape["opt_shape"]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(self.shape["opt_shape"]))
+ + " for opt_shape"
+ )
+ else:
+ internal_in.opt = self.shape["opt_shape"]
+
+ if not Input._supported_input_size_type(self.shape["max_shape"]):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(self.shape["max_shape"]))
+ + " for max_shape"
+ )
+ else:
+ internal_in.max = self.shape["max_shape"]
+ internal_in.input_is_dynamic = True
+ else:
+ if not Input._supported_input_size_type(self.shape):
+ raise TypeError(
+ "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+ + str(type(self.shape))
+ + " for shape"
+ )
+ else:
+ internal_in.opt = self.shape
+ internal_in.input_is_dynamic = False
+
+ if self.dtype != _enums.dtype.unknown:
+ self._explicit_set_dtype = True
+ else:
+ self._explicit_set_dtype = False
+
+ internal_in.dtype = Input._parse_dtype(self.dtype)
+ internal_in._explicit_set_dtype = self._explicit_set_dtype
+ internal_in.format = Input._parse_format(self.format)
+ return internal_in
+
+ @staticmethod
+ def _supported_input_size_type(input_size: Any) -> bool:
+ if isinstance(input_size, torch.Size):
+ return True
+ elif isinstance(input_size, tuple):
+ return True
+ elif isinstance(input_size, list):
+ return True
+ else:
+ return False
+
+ @staticmethod
+ def _parse_dtype(dtype: Any) -> _enums.dtype:
+ if isinstance(dtype, torch.dtype):
+ if dtype == torch.int32:
+ return _enums.dtype.int32
+ elif dtype == torch.half:
+ return _enums.dtype.half
+ elif dtype == torch.float:
+ return _enums.dtype.float
+ elif dtype == torch.bool:
+ return _enums.dtype.bool
+ else:
+ raise TypeError(
+ "Provided an unsupported data type as an input data type (support: bool, int32, half, float), got: "
+ + str(dtype)
+ )
+
+ elif isinstance(dtype, _enums.dtype):
+ return dtype
+
+ else:
+ raise TypeError(
+ "Input data type needs to be specified with a torch.dtype or a torch_tensorrt.dtype, got: "
+ + str(type(dtype))
+ )
+
+ @staticmethod
+ def _parse_format(format: Any) -> _enums.TensorFormat:
+ if isinstance(format, torch.memory_format):
+ if format == torch.contiguous_format:
+ return _enums.TensorFormat.contiguous
+ elif format == torch.channels_last:
+ return _enums.TensorFormat.channels_last
+ else:
+ raise ValueError(
+ "Provided an unsupported tensor format (support: NHCW/contiguous_format, NHWC/channel_last)"
+ )
+
+ elif isinstance(format, _enums.TensorFormat):
+ return format
+
+ else:
+ raise TypeError(
+ "Tensor format needs to be specified with either torch.memory_format or torch_tensorrt.TensorFormat"
+ )
+
+ @classmethod
+ def _from_tensor(cls, t: torch.Tensor):
+ if not any(
+ [
+ t.is_contiguous(memory_format=torch.contiguous_format),
+ t.is_contiguous(memory_format=torch.channels_last),
+ ]
+ ):
+ raise ValueError(
+ "Tensor does not have a supported contiguous memory format, supported formats are contiguous or channel_last"
+ )
+ frmt = (
+ torch.contiguous_format
+ if t.is_contiguous(memory_format=torch.contiguous_format)
+ else torch.channels_last
+ )
+ return cls(shape=t.shape, dtype=t.dtype, format=frmt)
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from typing import List, Dict, Any
+from torch_tensorrt import _enums
+import torch_tensorrt.ts
+from torch_tensorrt import logging
+import torch
+import torch.fx
+from enum import Enum
+
+import torch_tensorrt.fx
+import torch_tensorrt.fx.lower
+from torch_tensorrt.fx.utils import LowerPrecision
+
+
+class _IRType(Enum):
+ """Enum to set the minimum required logging level to print a message to stdout"""
+
+ ts = 0
+ fx = 1
+
+
+class _ModuleType(Enum):
+ """Enum to set the minimum required logging level to print a message to stdout"""
+
+ nn = 0
+ ts = 1
+ fx = 2
+
+
+def _parse_module_type(module: Any) -> _ModuleType:
+ if any(
+ isinstance(module, t)
+ for t in [torch.jit.ScriptModule, torch.jit.ScriptFunction]
+ ):
+ return _ModuleType.ts
+ elif isinstance(module, torch.fx.GraphModule):
+ return _ModuleType.fx
+ elif isinstance(module, torch.nn.Module):
+ return _ModuleType.nn
+ else:
+ raise RuntimeError("Module is an unknown format")
+
+
+def _get_target_ir(module_type: _ModuleType, ir: str) -> _IRType:
+ module_is_tsable = any([module_type == t for t in [_ModuleType.nn, _ModuleType.ts]])
+ module_is_fxable = any([module_type == t for t in [_ModuleType.nn, _ModuleType.fx]])
+
+ ir_targets_torchscript = any([ir == opt for opt in ["torchscript", "ts"]])
+ ir_targets_fx = ir == "fx"
+
+ if module_is_tsable and ir_targets_torchscript:
+ return _IRType.ts
+ elif module_is_fxable and ir_targets_fx:
+ return _IRType.fx
+ else:
+ if ir == "default":
+ # Options are listed in order of preference
+ if module_is_tsable:
+ logging.log(
+ logging.Level.Info, "ir was set to default, using TorchScript as ir"
+ )
+ return _IRType.ts
+ elif module_is_fxable:
+ raise ValueError(
+ "Was given a torch.fx.GraphModule, fx is not currently supported by Torch-TensorRT"
+ )
+ # logging.log(logging.Level.Info, "ir was set to default, using TorchScript as fx")
+ # return _IRType.fx
+ else:
+ raise ValueError("Module was provided with in an unsupported format")
+ else:
+ raise ValueError("Unknown ir was requested")
+
+
+[docs]def compile(
+ module: Any,
+ ir="default",
+ inputs=[],
+ enabled_precisions=set([_enums.dtype.float]),
+ **kwargs,
+):
+ """Compile a PyTorch module for NVIDIA GPUs using TensorRT
+
+ Takes a existing PyTorch module and a set of settings to configure the compiler
+ and using the path specified in ``ir`` lower and compile the module to TensorRT
+ returning a PyTorch Module back
+
+ Converts specifically the forward method of a Module
+
+ Arguments:
+ module (Union(torch.nn.Module,torch.jit.ScriptModule): Source module
+
+ Keyword Arguments:
+ inputs (List[Union(torch_tensorrt.Input, torch.Tensor)]): **Required** List of specifications of input shape, dtype and memory layout for inputs to the module. This argument is required. Input Sizes can be specified as torch sizes, tuples or lists. dtypes can be specified using
+ torch datatypes or torch_tensorrt datatypes and you can use either torch devices or the torch_tensorrt device type enum
+ to select device type. ::
+
+ input=[
+ torch_tensorrt.Input((1, 3, 224, 224)), # Static NCHW input shape for input #1
+ torch_tensorrt.Input(
+ min_shape=(1, 224, 224, 3),
+ opt_shape=(1, 512, 512, 3),
+ max_shape=(1, 1024, 1024, 3),
+ dtype=torch.int32
+ format=torch.channel_last
+ ), # Dynamic input shape for input #2
+ torch.randn((1, 3, 224, 244)) # Use an example tensor and let torch_tensorrt infer settings
+ ]
+
+ enabled_precision (Set(Union(torch.dtype, torch_tensorrt.dtype))): The set of datatypes that TensorRT can use when selecting kernels
+ ir (str): The requested strategy to compile. (Options: default - Let Torch-TensorRT decide, ts - TorchScript with scripting path)
+ **kwargs: Additional settings for the specific requested strategy (See submodules for more info)
+
+ Returns:
+ torch.nn.Module: Compiled Module, when run it will execute via TensorRT
+ """
+ module_type = _parse_module_type(module)
+ target_ir = _get_target_ir(module_type, ir)
+ if target_ir == _IRType.ts:
+ ts_mod = module
+ if module_type == _ModuleType.nn:
+ logging.log(
+ logging.Level.Info,
+ "Module was provided as a torch.nn.Module, trying to script the module with torch.jit.script. In the event of a failure please preconvert your module to TorchScript",
+ )
+ ts_mod = torch.jit.script(module)
+ return torch_tensorrt.ts.compile(
+ ts_mod, inputs=inputs, enabled_precisions=enabled_precisions, **kwargs
+ )
+ elif target_ir == _IRType.fx:
+ if (
+ torch.float16 in enabled_precisions
+ or torch_tensorrt.dtype.half in enabled_precisions
+ ):
+ lower_precision = LowerPrecision.FP16
+ elif (
+ torch.float32 in enabled_precisions
+ or torch_tensorrt.dtype.float in enabled_precisions
+ ):
+ lower_precision = LowerPrecision.FP32
+ else:
+ raise ValueError(f"Precision {enabled_precisions} not supported on FX")
+
+ return torch_tensorrt.fx.lower.compile(
+ module,
+ inputs,
+ lower_precision=lower_precision,
+ max_batch_size=inputs[0].size(0),
+ explicit_batch_dimension=True,
+ dynamic_batch=False,
+ )
+ else:
+ raise RuntimeError("Module is an unknown format or the ir requested is unknown")
+
+
+[docs]def convert_method_to_trt_engine(
+ module: Any,
+ method_name: str,
+ ir="default",
+ inputs=[],
+ enabled_precisions=set([_enums.dtype.float]),
+ **kwargs,
+):
+ """Convert a TorchScript module method to a serialized TensorRT engine
+
+ Converts a specified method of a module to a serialized TensorRT engine given a dictionary of conversion settings
+
+ Arguments:
+ module (Union(torch.nn.Module,torch.jit.ScriptModule): Source module
+
+ Keyword Arguments:
+ inputs (List[Union(torch_tensorrt.Input, torch.Tensor)]): **Required** List of specifications of input shape, dtype and memory layout for inputs to the module. This argument is required. Input Sizes can be specified as torch sizes, tuples or lists. dtypes can be specified using
+ torch datatypes or torch_tensorrt datatypes and you can use either torch devices or the torch_tensorrt device type enum
+ to select device type. ::
+
+ input=[
+ torch_tensorrt.Input((1, 3, 224, 224)), # Static NCHW input shape for input #1
+ torch_tensorrt.Input(
+ min_shape=(1, 224, 224, 3),
+ opt_shape=(1, 512, 512, 3),
+ max_shape=(1, 1024, 1024, 3),
+ dtype=torch.int32
+ format=torch.channel_last
+ ), # Dynamic input shape for input #2
+ torch.randn((1, 3, 224, 244)) # Use an example tensor and let torch_tensorrt infer settings
+ ]
+
+ enabled_precision (Set(Union(torch.dtype, torch_tensorrt.dtype))): The set of datatypes that TensorRT can use when selecting kernels
+ ir (str): The requested strategy to compile. (Options: default - Let Torch-TensorRT decide, ts - TorchScript with scripting path)
+ **kwargs: Additional settings for the specific requested strategy (See submodules for more info)
+ Returns:
+ bytes: Serialized TensorRT engine, can either be saved to a file or deserialized via TensorRT APIs
+ """
+ module_type = _parse_module_type(module)
+ target_ir = _get_target_ir(module_type, ir)
+ if target_ir == _IRType.ts:
+ ts_mod = module
+ if module_type == _ModuleType.nn:
+ logging.log(
+ logging.Level.Info,
+ "Module was provided as a torch.nn.Module, trying to script the module with torch.jit.script. In the event of a failure please preconvert your module to TorchScript",
+ )
+ ts_mod = torch.jit.script(module)
+ return torch_tensorrt.ts.convert_method_to_trt_engine(
+ ts_mod,
+ method_name,
+ inputs=inputs,
+ enabled_precisions=enabled_precisions,
+ **kwargs,
+ )
+ elif target_ir == _IRType.fx:
+ raise RuntimeError("fx is currently not supported")
+ else:
+ raise RuntimeError("Module is an unknown format or the ir requested is unknown")
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from torch_tensorrt import __version__
+from torch_tensorrt import _C
+
+import torch
+
+
+[docs]def dump_build_info():
+ """Prints build information about the torch_tensorrt distribution to stdout"""
+ print(get_build_info())
+
+
+[docs]def get_build_info() -> str:
+ """Returns a string containing the build information of torch_tensorrt distribution
+
+ Returns:
+ str: String containing the build information for torch_tensorrt distribution
+ """
+ build_info = _C.get_build_info()
+ build_info = (
+ "Torch-TensorRT Version: "
+ + str(__version__)
+ + "\n"
+ + "Using PyTorch Version: "
+ + str(torch.__version__)
+ + "\n"
+ + build_info
+ )
+ return build_info
+
+
+
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+import logging
+import warnings
+from datetime import datetime
+from typing import Any, Callable, Dict, List, NamedTuple, Optional, Sequence
+
+import numpy
+
+# @manual=//deeplearning/trt/python:py_tensorrt
+import tensorrt as trt
+import torch
+import torch.fx
+from torch.fx.node import _get_qualified_name
+from torch.fx.passes.shape_prop import TensorMetadata
+
+from .converter_registry import CONVERTERS
+from .input_tensor_spec import InputTensorSpec
+from .observer import Observer
+from .utils import get_dynamic_dims, LowerPrecision, torch_dtype_to_trt
+
+_LOGGER: logging.Logger = logging.getLogger(__name__)
+
+TRT_INTERPRETER_CALL_PRE_OBSERVER: Observer[
+ Callable[[torch.fx.GraphModule], None]
+] = Observer("TRT_INTERPRETER_CALL_PRE_OBSERVER")
+
+
+[docs]class TRTInterpreterResult(NamedTuple):
+ engine: Any
+ input_names: Sequence[str]
+ output_names: Sequence[str]
+ serialized_cache: bytearray
+
+
+[docs]class TRTInterpreter(torch.fx.Interpreter):
+ def __init__(
+ self,
+ module: torch.fx.GraphModule,
+ input_specs: List[InputTensorSpec],
+ explicit_batch_dimension: bool = False,
+ explicit_precision: bool = False,
+ logger_level=None,
+ ):
+ super().__init__(module)
+
+ self.logger = trt.Logger(logger_level or trt.Logger.WARNING)
+ self.builder = trt.Builder(self.logger)
+
+ flag = 0
+ if explicit_batch_dimension:
+ EXPLICIT_BATCH = 1 << (int)(
+ trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH
+ )
+ flag |= EXPLICIT_BATCH
+
+ if explicit_precision:
+ EXPLICIT_PRECISION = 1 << (int)(
+ trt.NetworkDefinitionCreationFlag.EXPLICIT_PRECISION
+ )
+ flag |= EXPLICIT_PRECISION
+ self.network = self.builder.create_network(flag)
+
+ missing_ops = self.validate_conversion()
+ if missing_ops:
+ warnings.warn(
+ "Interpretation will fail due to missing operations \n"
+ + "\n".join(f"{i}" for i in missing_ops)
+ )
+
+ self.optimization_profiles: Optional[List] = None
+ self.input_specs = input_specs
+ self.input_specs_iter = 0
+ self.validate_input_specs()
+ self._cur_node_name: Optional[str] = None
+ self._input_names: List[str] = []
+ self._output_names: List[str] = []
+ self._itensor_to_tensor_meta: Dict[
+ trt.tensorrt.ITensor, TensorMetadata
+ ] = dict()
+
+ def validate_input_specs(self):
+ for shape, _, _, shape_ranges, has_batch_dim in self.input_specs:
+ if not self.network.has_implicit_batch_dimension:
+ assert (
+ has_batch_dim
+ ), "It's required to specify batch dimension when it's explicit in TensorRT network."
+
+ dynamic_dims = get_dynamic_dims(shape)
+ if len(dynamic_dims):
+ assert not self.network.has_implicit_batch_dimension, (
+ "Can't have dynamic dim when "
+ f"batch dim is implicit, got {shape}."
+ )
+ assert len(
+ shape_ranges
+ ), "shape_ranges must be provided when shape has dynamic dim."
+
+ if self.optimization_profiles:
+ assert len(shape_ranges) == len(self.optimization_profiles), (
+ "Number of optimization "
+ f"profiles {len(self.optimization_profiles)} doesn't match with the number of shape_range"
+ f" {len(shape_ranges)} provided."
+ )
+ else:
+ self.optimization_profiles = [
+ self.builder.create_optimization_profile()
+ for _ in range(len(shape_ranges))
+ ]
+
+ for shape_range in shape_ranges:
+ assert (
+ len(shape_range) == 3
+ ), f"Expect three elements in shape_range, got {len(shape_range)}"
+ assert all(len(s) == len(shape) for s in shape_range), (
+ "Expect elements in shape_range"
+ f" {shape_range} have the same number of dimension as the provided shape {len(shape)}"
+ )
+
+ for i in range(len(shape)):
+ if i in dynamic_dims:
+ assert all(
+ shape_range[j][i] <= shape_range[j + 1][i]
+ for j in range(2)
+ ), (
+ "Expect dynamic dim"
+ f" {i} to have incremental value for shapes in shape_range {shape_range}."
+ )
+ else:
+ assert all(s[i] == shape[i] for s in shape_range), (
+ f"Expect non dynamic dim {i} to be the same"
+ f" for all shapes in shape_range {shape_range}."
+ )
+ else:
+ assert (
+ len(shape_ranges) == 0
+ ), "shape_ranges are provided for input that doesn't have dynamic dim."
+
+ def validate_conversion(self):
+ missing_converter = set()
+
+ for node in self.module.graph.nodes:
+ if node.op == "call_function" and not CONVERTERS.get(node.target):
+ missing_converter.add(f"{node.op} {_get_qualified_name(node.target)}")
+ elif node.op == "call_method" and not CONVERTERS.get(node.target):
+ missing_converter.add(f"{node.op} torch.Tensor.{node.target}")
+ elif node.op == "call_module":
+ submod = self.fetch_attr(node.target)
+ submod_type = getattr(submod, "_base_class_origin", type(submod))
+ if not CONVERTERS.get(submod_type):
+ missing_converter.add(f"{node.op} {torch.typename(submod_type)}")
+
+ return missing_converter
+
+ def run(
+ self,
+ max_batch_size=64,
+ max_workspace_size=1 << 25,
+ lower_precision=LowerPrecision.FP16,
+ sparse_weights=False,
+ force_fp32_output=False,
+ strict_type_constraints=False,
+ algorithm_selector=None,
+ timing_cache=None,
+ profiling_verbosity=None,
+ tactic_sources=None,
+ ) -> TRTInterpreterResult:
+ """
+ Build TensorRT engine with some configs.
+ Args:
+ max_batch_size: set accordingly for maximum batch size you will use.
+ max_workspace_size: set to the maximum size we can afford for temporary buffer
+ lower_precision: the precision model layers are running on (TensorRT will choose the best perforamnce precision).
+ sparse_weights: allow the builder to examine weights and use optimized functions when weights have suitable sparsity
+ force_fp32_output: force output to be fp32
+ strict_type_constraints: Usually we should set it to False unless we want to control the precision of certain layer for numeric reasons.
+ algorithm_selector: set up algorithm selection for certain layer
+ timing_cache: enable timing cache for TensorRT
+ profiling_verbosity: TensorRT logging level
+ Return:
+ TRTInterpreterResult
+ """
+ TRT_INTERPRETER_CALL_PRE_OBSERVER.observe(self.module)
+
+ # For float outputs, we set their dtype to fp16 only if lower_precision == LowerPrecision.FP16 and
+ # force_fp32_output=False.
+ self.output_fp16 = (
+ not force_fp32_output and lower_precision == LowerPrecision.FP16
+ )
+
+ if (
+ lower_precision == LowerPrecision.INT8
+ and not self.builder.platform_has_fast_int8
+ ):
+ raise RuntimeError("Current platform doesn't support fast native int8!")
+
+ if (
+ lower_precision == LowerPrecision.FP16
+ and not self.builder.platform_has_fast_fp16
+ ):
+ warnings.warn("Current platform doesn't support fast native fp16!")
+
+ self.input_specs_iter = 0
+ run_module_start_time = datetime.now()
+ super().run()
+ _LOGGER.info(
+ f"Run Module elapsed time: {datetime.now() - run_module_start_time}"
+ )
+ build_engine_start_time = datetime.now()
+
+ self.builder.max_batch_size = max_batch_size
+ builder_config = self.builder.create_builder_config()
+ builder_config.max_workspace_size = max_workspace_size
+
+ cache = None
+ if timing_cache:
+ cache_file = numpy.array(timing_cache)
+ cache = builder_config.create_timing_cache(cache_file.tobytes())
+ else:
+ cache = builder_config.create_timing_cache(b"")
+ builder_config.set_timing_cache(cache, False)
+
+ if trt.__version__ >= "8.2":
+ builder_config.profiling_verbosity = (
+ profiling_verbosity
+ if profiling_verbosity
+ else trt.ProfilingVerbosity.LAYER_NAMES_ONLY
+ )
+ if lower_precision == LowerPrecision.FP16:
+ builder_config.set_flag(trt.BuilderFlag.FP16)
+
+ if lower_precision == LowerPrecision.INT8:
+ builder_config.set_flag(trt.BuilderFlag.INT8)
+
+ if sparse_weights:
+ builder_config.set_flag(trt.BuilderFlag.SPARSE_WEIGHTS)
+
+ if strict_type_constraints:
+ builder_config.set_flag(trt.BuilderFlag.STRICT_TYPES)
+
+ if self.optimization_profiles:
+ for optimization_profile in self.optimization_profiles:
+ builder_config.add_optimization_profile(optimization_profile)
+
+ if algorithm_selector:
+ builder_config.set_flag(trt.BuilderFlag.DISABLE_TIMING_CACHE)
+ builder_config.algorithm_selector = algorithm_selector
+
+ if tactic_sources is not None:
+ builder_config.set_tactic_sources(tactic_sources=tactic_sources)
+
+ engine = self.builder.build_engine(self.network, builder_config)
+ assert engine
+
+ serialized_cache = (
+ bytearray(cache.serialize())
+ if builder_config.get_timing_cache()
+ else bytearray()
+ )
+ _LOGGER.info(
+ f"Build TRT engine elapsed time: {datetime.now() - build_engine_start_time}"
+ )
+
+ return TRTInterpreterResult(
+ engine, self._input_names, self._output_names, serialized_cache
+ )
+
+ def run_node(self, n):
+ self._cur_node_name = str(n)
+ # add "_itensor_to_tensor_meta"
+ kwargs = dict(n.kwargs)
+ kwargs["_itensor_to_tensor_meta"] = self._itensor_to_tensor_meta
+ n.kwargs = kwargs
+
+ # run the node
+ trt_node = super().run_node(n)
+
+ # remove "_itensor_to_tensor_meta"
+ kwargs = dict(n.kwargs)
+ del kwargs["_itensor_to_tensor_meta"]
+ n.kwargs = kwargs
+
+ if isinstance(trt_node, trt.tensorrt.ITensor):
+ self._itensor_to_tensor_meta[trt_node] = n.meta.get("tensor_meta")
+
+ return trt_node
+
+ def placeholder(self, target, args, kwargs):
+ self._input_names.append(target)
+ shape, dtype, _, shape_ranges, has_batch_dim = self.input_specs[
+ self.input_specs_iter
+ ]
+ self.input_specs_iter += 1
+
+ if self.network.has_implicit_batch_dimension:
+ if has_batch_dim:
+ shape = shape[1:]
+ else:
+ for i, shape_range in enumerate(shape_ranges):
+ assert self.optimization_profiles
+ self.optimization_profiles[i].set_shape(target, *shape_range)
+
+ return self.network.add_input(
+ name=target, shape=tuple(shape), dtype=torch_dtype_to_trt(dtype)
+ )
+
+ def call_module(self, target, args, kwargs):
+ assert isinstance(target, str)
+ submod = self.fetch_attr(target)
+ submod_type = getattr(submod, "_base_class_origin", type(submod))
+ converter = CONVERTERS.get(submod_type)
+
+ if not converter:
+ raise RuntimeError(
+ f"Conversion of module of type {submod_type} not currently supported!"
+ )
+
+ assert self._cur_node_name is not None
+ return converter(self.network, submod, args, kwargs, self._cur_node_name)
+
+ def call_function(self, target, args, kwargs):
+ converter = CONVERTERS.get(target)
+
+ if not converter:
+ raise RuntimeError(
+ f"Conversion of function {torch.typename(target)} not currently supported!"
+ )
+
+ assert self._cur_node_name is not None
+ return converter(self.network, target, args, kwargs, self._cur_node_name)
+
+ def call_method(self, target, args, kwargs):
+ assert isinstance(target, str)
+ converter = CONVERTERS.get(target)
+
+ if not converter:
+ raise RuntimeError(
+ f"Conversion of method {target} not currently supported!"
+ )
+
+ assert self._cur_node_name is not None
+ return converter(self.network, target, args, kwargs, self._cur_node_name)
+
+ def output(self, target, args, kwargs):
+ assert len(args) == 1
+ outputs = args[0] if isinstance(args[0], tuple) else (args[0],)
+
+ if not all(isinstance(output, trt.tensorrt.ITensor) for output in outputs):
+ raise RuntimeError("TensorRT requires all outputs to be Tensor!")
+
+ for i, output in enumerate(outputs):
+ if any(
+ op_name in output.name.split("_")
+ for op_name in (
+ "eq",
+ "gt",
+ "lt",
+ "or",
+ "xor",
+ "and",
+ "not",
+ "ne",
+ "isinf",
+ "any",
+ )
+ ):
+ output_bool = True
+ else:
+ output_bool = False
+ name = f"output{i}"
+ output.name = name
+ self.network.mark_output(output)
+ if output_bool:
+ output.dtype = trt.bool
+ elif self.output_fp16 and output.dtype == trt.float32:
+ output.dtype = trt.float16
+ self._output_names.append(name)
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from typing import Iterable, List, NamedTuple, Optional, Sequence, Tuple
+
+import torch
+
+from .types import Shape, ShapeRange
+from .utils import get_dynamic_dims
+
+
+def generate_input_specs(inputs, lower_setting, additional_inputs=None):
+ # dynamic_batch is TRT only flag.
+ if (
+ not lower_setting.explicit_batch_dimension
+ or lower_setting.dynamic_batch is False
+ ):
+ return InputTensorSpec.from_tensors(inputs)
+
+ # If we don't have additional inputs, we assume the first dimension
+ # is the dynamic batch dimension. Otherwise, we use the additional
+ # inputs to determine the batch dimension.
+ if additional_inputs is None:
+ return InputTensorSpec.from_tensors_with_dynamic_batch_size(
+ inputs,
+ (
+ 0,
+ lower_setting.max_batch_size,
+ lower_setting.max_batch_size,
+ ),
+ lower_setting.opt_profile_replica,
+ )
+ else:
+ batch_dims = []
+
+ for i, j in zip(inputs, additional_inputs):
+ found_batch_dim = False
+
+ for idx, values in enumerate(zip(i.shape, j.shape)):
+ if values[0] != values[1]:
+ assert (
+ found_batch_dim is False
+ ), f"We've already found a batch dim, {i.shape}, {j.shape}."
+ batch_dims.append(idx)
+ found_batch_dim = True
+
+ if not found_batch_dim:
+ raise RuntimeError(
+ f"Failed to find batch dimension because shapes are the same, {i.shape}"
+ )
+
+ return InputTensorSpec.from_tensors_with_dynamic_batch_size(
+ inputs,
+ (
+ 0,
+ lower_setting.max_batch_size,
+ lower_setting.max_batch_size,
+ ),
+ lower_setting.opt_profile_replica,
+ batch_dims,
+ )
+
+
+[docs]class InputTensorSpec(NamedTuple):
+ """
+ This class contains the information of a input tensor.
+
+ shape: shape of the tensor.
+
+ dtype: dtyep of the tensor.
+
+ device: device of the tensor. This is only used to generate inputs to the given model
+ in order to run shape prop. For TensorRT engine, inputs have to be on cuda device.
+
+ shape_ranges: If dynamic shape is needed (shape has dimensions of -1), then this field
+ has to be provided (default is empty list). Every shape_range is a tuple of three
+ tuples ((min_input_shape), (optimized_input_shape), (max_input_shape)). Each shape_range
+ is used to populate a TensorRT optimization profile.
+ e.g. If the input shape varies from (1, 224) to (100, 224) and we want to optimize
+ for (25, 224) because it's the most common input shape, then we set shape_ranges to
+ ((1, 224), (25, 225), (100, 224)).
+
+ has_batch_dim: Whether the shape includes batch dimension. Batch dimension has to be provided
+ if the engine want to run with dynamic shape.
+ """
+
+ shape: Shape
+ dtype: torch.dtype
+ device: torch.device = torch.device("cpu")
+ shape_ranges: List[ShapeRange] = []
+ has_batch_dim: bool = True
+
+ @classmethod
+ def from_tensor(cls, tensor: torch.Tensor) -> "InputTensorSpec":
+ """
+ Produce an InputTenosrSpec named tuple which contains the
+ information of the given PyTorch tensor.
+
+ Args:
+ tensor (torch.Tensor): A PyTorch tensor.
+
+ Returns:
+ An InputTensorSpec named tuple.
+ """
+ return cls(tensor.shape, tensor.dtype, tensor.device)
+
+ @classmethod
+ def from_tensors(cls, tensors: Sequence[torch.Tensor]) -> List["InputTensorSpec"]:
+ """
+ Produce a list of InputTenosrSpec named tuples which contain
+ the information of all the given PyTorch tensors.
+
+ Args:
+ tensors (Iterable[torch.Tensor]): A list of PyTorch tensors.
+
+ Returns:
+ A list of InputTensorSpec named tuples.
+ """
+ assert isinstance(tensors, (list, tuple))
+ return [cls.from_tensor(t) for t in tensors]
+
+ @classmethod
+ def from_tensors_with_dynamic_batch_size(
+ cls,
+ tensors: Sequence[torch.Tensor],
+ batch_size_range: Tuple[int, int, int],
+ opt_profile_replica: int = 1,
+ batch_dims: Optional[List[int]] = None,
+ ) -> List["InputTensorSpec"]:
+ """
+ Produce a list of InputTenosrSpec named tuples which would contain
+ the information of all the given PyTorch tensors. The produced input
+ tensor specs will treat all tensors' first dimension as batch dimension
+ and mark them as dynmaic.
+
+ Args:
+ tensors (Sequence[torch.Tensor]): A list of PyTorch tensors.
+ batch_size_range (Tuple[int, int, int]): The first integer indicates
+ the smallest batch size allowed. The second integer indiceates
+ the batch size that we'll optimize for. The third integer indicates
+ the largest batch size allowed.
+ opt_profile_replica (int): If dynamic shape is enabled, each execution
+ context requires a different optimization profile. This arg determines
+ how many optimization profile replicas we want to produce.
+ batch_dims (Optional[List[int]]): The batch dim might not be the leading dim
+ and allow user to specify the batch dims using this arg. Default we treat
+ dim 0 as the batch dim.
+
+ Returns:
+ A list of InputTensorSpec named tuples with dynamic ranges.
+ """
+ if batch_dims is None:
+ batch_dims = [0] * len(tensors)
+
+ input_specs = []
+ batch_size = tensors[0].size(batch_dims[0])
+
+ for i, tensor in enumerate(tensors):
+ batch_dim = batch_dims[i]
+ assert batch_size == tensor.size(
+ batch_dim
+ ), f"The {i}th tensor (shape: {tensor.shape}) doesn't have the correct batch size: {batch_size}."
+ shape = list(tensor.shape)
+ shape[batch_dim] = -1
+ shape_ranges: List[ShapeRange] = [tuple(tuple(shape[0:batch_dim] + [bs] + shape[batch_dim + 1 :]) for bs in batch_size_range)] * opt_profile_replica # type: ignore[list-item]
+ input_specs.append(
+ cls(tuple(shape), tensor.dtype, tensor.device, shape_ranges)
+ )
+
+ return input_specs
+
+ def to_random_tensor(self):
+ shape = tuple(self.shape)
+ if len(get_dynamic_dims(shape)):
+ shape = tuple(self.shape_ranges[0][1])
+ elif not self.has_batch_dim:
+ shape = (1,) + tuple(shape)
+
+ return torch.randn(shape).to(dtype=self.dtype, device=self.device)
+
+ @staticmethod
+ def create_inputs_from_specs(input_specs: Iterable["InputTensorSpec"]):
+ inputs = []
+
+ for spec in input_specs:
+ inputs.append(spec.to_random_tensor())
+
+ return inputs
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+import dataclasses as dc
+import logging
+from typing import Any, Callable, Optional, Sequence
+
+# @manual=//deeplearning/trt/python:py_tensorrt
+import tensorrt as trt
+import torch
+import torch.fx as fx
+import torch.nn as nn
+from torch.fx.passes.splitter_base import SplitResult
+
+from .fx2trt import TRTInterpreter, TRTInterpreterResult
+from .lower_setting import LowerSetting
+from .passes.lower_pass_manager_builder import LowerPassManagerBuilder
+from .passes.pass_utils import decorate_method, PassFunc, validate_inference
+from .tools.timing_cache_utils import TimingCacheManager
+from .tools.trt_splitter import TRTSplitter, TRTSplitterSetting
+
+from .tracer.acc_tracer import acc_tracer
+from .trt_module import TRTModule
+from .utils import LowerPrecision
+
+logger = logging.getLogger(__name__)
+
+Input = Sequence[Any]
+
+
+[docs]def compile(
+ module: nn.Module,
+ input,
+ max_batch_size: int = 2048,
+ max_workspace_size=1 << 25,
+ explicit_batch_dimension=False,
+ lower_precision=LowerPrecision.FP16,
+ verbose_log=False,
+ timing_cache_prefix="",
+ save_timing_cache=False,
+ cuda_graph_batch_size=-1,
+ dynamic_batch=True,
+) -> nn.Module:
+ """
+ Takes in original module, input and lowering setting, run lowering workflow to turn module
+ into lowered module, or so called TRTModule.
+
+ Args:
+ module: Original module for lowering.
+ input: Input for module.
+ max_batch_size: Maximum batch size (must be >= 1 to be set, 0 means not set)
+ max_workspace_size: Maximum size of workspace given to TensorRT.
+ explicit_batch_dimension: Use explicit batch dimension in TensorRT if set True, otherwise use implicit batch dimension.
+ lower_precision: lower_precision config given to TRTModule.
+ verbose_log: Enable verbose log for TensorRT if set True.
+ timing_cache_prefix: Timing cache file name for timing cache used by fx2trt.
+ save_timing_cache: Update timing cache with current timing cache data if set to True.
+ cuda_graph_batch_size: Cuda graph batch size, default to be -1.
+
+ Returns:
+ A torch.nn.Module lowered by TensorRT.
+ """
+ lower_setting = LowerSetting(
+ max_batch_size=max_batch_size,
+ max_workspace_size=max_workspace_size,
+ explicit_batch_dimension=explicit_batch_dimension,
+ lower_precision=lower_precision,
+ verbose_log=verbose_log,
+ timing_cache_prefix=timing_cache_prefix,
+ save_timing_cache=save_timing_cache,
+ cuda_graph_batch_size=cuda_graph_batch_size,
+ dynamic_batch=dynamic_batch,
+ )
+ lowerer = Lowerer.create(lower_setting=lower_setting)
+ return lowerer(module, input)
+
+
+@dc.dataclass
+class LowerTrtInterpreter:
+ lower_setting: LowerSetting
+ timing_cache_manager: TimingCacheManager
+
+ @classmethod
+ def create(cls, lower_setting):
+ timing_cache_manager = TimingCacheManager(
+ lower_setting.timing_cache_prefix, lower_setting.save_timing_cache
+ )
+ return LowerTrtInterpreter(lower_setting, timing_cache_manager)
+
+ def __call__(self, mod, input, split_name) -> TRTInterpreterResult:
+ assert self.lower_setting.input_specs, "Can't find input specs for lowering!"
+ logger.info(f"{split_name=} {self.lower_setting.input_specs=}")
+
+ # Prepare algorithm selector and timing_cache for TRTInterpreter
+ algo_selector = None
+ if self.lower_setting.algo_selector:
+ algo_selector = self.lower_setting.algo_selector(f"{split_name}.json")
+ cache_data = None
+ if self.timing_cache_manager:
+ try:
+ cache_data = self.timing_cache_manager.get_timing_cache_trt(split_name)
+ except Exception as e:
+ logger.warning(f"Cannot load timing cache for {split_name}: {str(e)}")
+ cache_data = None
+
+ interpreter = TRTInterpreter(
+ mod,
+ input_specs=self.lower_setting.input_specs,
+ explicit_batch_dimension=self.lower_setting.explicit_batch_dimension,
+ explicit_precision=self.lower_setting.explicit_precision,
+ logger_level=trt.Logger.VERBOSE
+ if self.lower_setting.verbose_log
+ else trt.Logger.WARNING,
+ )
+
+ interp_result: TRTInterpreterResult = interpreter.run(
+ max_batch_size=self.lower_setting.max_batch_size,
+ max_workspace_size=self.lower_setting.max_workspace_size,
+ lower_precision=self.lower_setting.lower_precision,
+ strict_type_constraints=self.lower_setting.strict_type_constraints,
+ algorithm_selector=algo_selector,
+ timing_cache=cache_data,
+ profiling_verbosity=trt.ProfilingVerbosity.DETAILED
+ if self.lower_setting.verbose_profile
+ else trt.ProfilingVerbosity.LAYER_NAMES_ONLY,
+ tactic_sources=self.lower_setting.tactic_sources,
+ )
+
+ # Update timing cache file if needed
+ timing_cache = interp_result.serialized_cache
+ if timing_cache and self.timing_cache_manager:
+ self.timing_cache_manager.update_timing_cache(split_name, timing_cache)
+
+ return interp_result
+
+
+def default_split_function(
+ model: fx.GraphModule, inputs: Input, lower_setting: LowerSetting
+) -> SplitResult:
+ splitter_setting = TRTSplitterSetting()
+ splitter_setting.use_implicit_batch_dim = not lower_setting.explicit_batch_dimension
+ splitter_setting.min_acc_module_size = lower_setting.min_acc_module_size
+ splitter = TRTSplitter(model, inputs, settings=splitter_setting)
+ splitter.node_support_preview()
+ return splitter.generate_split_results()
+
+
+def create_lower_trt_interpreter(lower_setting: LowerSetting) -> LowerTrtInterpreter:
+ return LowerTrtInterpreter.create(lower_setting)
+
+
+def default_lower_pass(
+ create_trt_interpreter: Callable[[LowerSetting], LowerTrtInterpreter],
+) -> PassFunc:
+ def lower_pass(
+ mod: nn.Module, input: Input, lower_setting: LowerSetting, module_name: str
+ ) -> nn.Module:
+ """
+ Create a module transformation pass which lowers an `fx.GraphModule` into a
+ `TRTModule`
+ """
+ interpreter = create_trt_interpreter(lower_setting)
+ interp_res: TRTInterpreterResult = interpreter(mod, input, module_name)
+ trt_module = TRTModule(
+ engine=interp_res.engine,
+ input_names=interp_res.input_names,
+ output_names=interp_res.output_names,
+ cuda_graph_batch_size=lower_setting.cuda_graph_batch_size,
+ )
+ return trt_module
+
+ return lower_pass
+
+
+@dc.dataclass(frozen=True)
+class Lowerer:
+ """Lowers a module using fx2trt.
+
+ This is a composable class to facilitate fx2trt. A normal fx2trt process
+ composes of the following passes to transform an `fx.GraphModule`:
+
+ 1. trace - use torch.fx to trace the module so we can get the graph
+ representation of the model.
+ 2. split - the graph module is split into several submodules,
+ running either via TensorRT, or via regular CUDA.
+
+ For each split that need to run via TRT, the following passes are
+ invoked:
+
+ 3. `TRTInterpreter` - build the TRT engine for the submodule that
+ can be supported through `TRTInterpreter`.
+ 4. Wraps the executable TRT engine into `TRTModule`, which is an `nn.Module`.
+ 5. The converted submodule is then set back onto the top-level module
+
+ """
+
+ lower_pass_manager_builder: LowerPassManagerBuilder
+
+ @classmethod
+ def create(
+ cls,
+ lower_setting: LowerSetting,
+ interpreter_builder: Callable = create_lower_trt_interpreter,
+ split_func: Callable = default_split_function,
+ ) -> "Lowerer":
+ """Instantiate a `Lowerer` instance."""
+
+ return cls(
+ lower_pass_manager_builder=LowerPassManagerBuilder(
+ lower_setting=lower_setting,
+ trace_func=lambda module, inputs: acc_tracer.trace(
+ module,
+ inputs, # type: ignore[arg-type]
+ ast_rewriter_allow_list=lower_setting.ast_rewriter_allow_list,
+ leaf_module_list=lower_setting.leaf_module_list,
+ ),
+ split_func=split_func,
+ lower_func=default_lower_pass(interpreter_builder),
+ )
+ )
+
+ def __call__(
+ self,
+ module: nn.Module,
+ inputs: Input,
+ additional_inputs: Optional[Input] = None,
+ ) -> nn.Module:
+ lower_setting = self.lower_pass_manager_builder.lower_setting
+ atol = lower_setting.correctness_atol
+ rtol = lower_setting.correctness_rtol
+
+ @validate_inference(atol=atol, rtol=rtol)
+ def do_lower(module: nn.Module, inputs: Input) -> nn.Module:
+ module.eval()
+ if (
+ self.lower_pass_manager_builder.lower_setting.lower_precision
+ == LowerPrecision.FP16
+ ):
+ module.half()
+ inputs = tuple(
+ x.half() if x is not None and x.dtype == torch.float32 else x
+ for x in inputs
+ )
+ pm = self.lower_pass_manager_builder.build_trt_lower_pipeline(
+ inputs, additional_inputs
+ )
+ lower_result = pm(module)
+ return lower_result
+
+ return do_lower(module, inputs)
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from typing import Any, List, Sequence
+
+# @manual=//deeplearning/trt/python:py_tensorrt
+import tensorrt as trt
+import torch
+
+from .utils import torch_dtype_from_trt
+
+
+[docs]class TRTModule(torch.nn.Module):
+ def __init__(
+ self, engine=None, input_names=None, output_names=None, cuda_graph_batch_size=-1
+ ):
+ super(TRTModule, self).__init__()
+ self._register_state_dict_hook(TRTModule._on_state_dict)
+ self.engine = engine
+ self.input_names = input_names
+ self.output_names = output_names
+ self.cuda_graph_batch_size = cuda_graph_batch_size
+ self.initialized = False
+
+ if engine:
+ self._initialize()
+
+ def _initialize(self):
+ self.initialized = True
+ self.context = self.engine.create_execution_context()
+
+ # Indices of inputs/outputs in the trt engine bindings, in the order
+ # as they are in the original PyTorch model.
+ self.input_binding_indices_in_order: Sequence[int] = [
+ self.engine.get_binding_index(name) for name in self.input_names
+ ]
+ self.output_binding_indices_in_order: Sequence[int] = [
+ self.engine.get_binding_index(name) for name in self.output_names
+ ]
+ primary_input_outputs = set()
+ primary_input_outputs.update(self.input_binding_indices_in_order)
+ primary_input_outputs.update(self.output_binding_indices_in_order)
+ self.hidden_output_binding_indices_in_order: Sequence[int] = []
+ self.hidden_output_names: Sequence[str] = []
+ for i in range(
+ self.engine.num_bindings // self.engine.num_optimization_profiles
+ ):
+ if i not in primary_input_outputs:
+ self.hidden_output_binding_indices_in_order.append(i)
+ self.hidden_output_names.append(self.engine.get_binding_name(i))
+
+ assert (self.engine.num_bindings // self.engine.num_optimization_profiles) == (
+ len(self.input_names)
+ + len(self.output_names)
+ + len(self.hidden_output_names)
+ )
+
+ self.input_dtypes: Sequence[torch.dtype] = [
+ torch_dtype_from_trt(self.engine.get_binding_dtype(idx))
+ for idx in self.input_binding_indices_in_order
+ ]
+ self.input_shapes: Sequence[Sequence[int]] = [
+ tuple(self.engine.get_binding_shape(idx))
+ for idx in self.input_binding_indices_in_order
+ ]
+ self.output_dtypes: Sequence[torch.dtype] = [
+ torch_dtype_from_trt(self.engine.get_binding_dtype(idx))
+ for idx in self.output_binding_indices_in_order
+ ]
+ self.output_shapes = [
+ tuple(self.engine.get_binding_shape(idx))
+ if self.engine.has_implicit_batch_dimension
+ else tuple()
+ for idx in self.output_binding_indices_in_order
+ ]
+ self.hidden_output_dtypes: Sequence[torch.dtype] = [
+ torch_dtype_from_trt(self.engine.get_binding_dtype(idx))
+ for idx in self.hidden_output_binding_indices_in_order
+ ]
+ self.hidden_output_shapes = [
+ tuple(self.engine.get_binding_shape(idx))
+ if self.engine.has_implicit_batch_dimension
+ else tuple()
+ for idx in self.hidden_output_binding_indices_in_order
+ ]
+
+ def _check_initialized(self):
+ if not self.initialized:
+ raise RuntimeError("TRTModule is not initialized.")
+
+ def _on_state_dict(self, state_dict, prefix, local_metadata):
+ self._check_initialized()
+ state_dict[prefix + "engine"] = bytearray(self.engine.serialize())
+ state_dict[prefix + "input_names"] = self.input_names
+ state_dict[prefix + "output_names"] = self.output_names
+ state_dict[prefix + "cuda_graph_batch_size"] = self.cuda_graph_batch_size
+
+ def _load_from_state_dict(
+ self,
+ state_dict,
+ prefix,
+ local_metadata,
+ strict,
+ missing_keys,
+ unexpected_keys,
+ error_msgs,
+ ):
+ engine_bytes = state_dict[prefix + "engine"]
+
+ logger = trt.Logger()
+ runtime = trt.Runtime(logger)
+ self.engine = runtime.deserialize_cuda_engine(engine_bytes)
+
+ self.input_names = state_dict[prefix + "input_names"]
+ self.output_names = state_dict[prefix + "output_names"]
+ self._initialize()
+
+ def __getstate__(self):
+ state = self.__dict__.copy()
+ state["engine"] = bytearray(self.engine.serialize())
+ state.pop("context", None)
+ return state
+
+ def __setstate__(self, state):
+ logger = trt.Logger()
+ runtime = trt.Runtime(logger)
+ state["engine"] = runtime.deserialize_cuda_engine(state["engine"])
+ self.__dict__.update(state)
+ if self.engine:
+ self.context = self.engine.create_execution_context()
+
+ def forward(self, *inputs):
+ with torch.autograd.profiler.record_function("TRTModule:Forward"):
+ self._check_initialized()
+
+ with torch.autograd.profiler.record_function("TRTModule:ProcessInputs"):
+ assert len(inputs) == len(
+ self.input_names
+ ), f"Wrong number of inputs, expect {len(self.input_names)} get {len(inputs)}."
+
+ # This is only used when the trt engine is using implicit batch dim.
+ batch_size = inputs[0].shape[0]
+ contiguous_inputs: List[torch.Tensor] = [i.contiguous() for i in inputs]
+ bindings: List[Any] = [None] * (
+ len(self.input_names)
+ + len(self.output_names)
+ + len(self.hidden_output_names)
+ )
+
+ for i, input_name in enumerate(self.input_names):
+ assert inputs[
+ i
+ ].is_cuda, f"{i}th input({input_name}) is not on cuda device."
+ assert (
+ inputs[i].dtype == self.input_dtypes[i]
+ ), f"Dtype mismatch for {i}th input({input_name}). Expect {self.input_dtypes[i]}, got {inputs[i].dtype}."
+
+ idx = self.input_binding_indices_in_order[i]
+ bindings[idx] = contiguous_inputs[i].data_ptr()
+
+ if not self.engine.has_implicit_batch_dimension:
+ self.context.set_binding_shape(
+ idx, tuple(contiguous_inputs[i].shape)
+ )
+ else:
+ assert inputs[i].size()[1:] == self.input_shapes[i], (
+ f"Shape mismatch for {i}th input({input_name}). "
+ f"Expect {self.input_shapes[i]}, got {inputs[i].size()[1:]}."
+ )
+
+ with torch.autograd.profiler.record_function("TRTModule:ProcessOutputs"):
+ # create output tensors
+ outputs: List[torch.Tensor] = []
+
+ for i, idx in enumerate(self.output_binding_indices_in_order):
+ if self.engine.has_implicit_batch_dimension:
+ shape = (batch_size,) + self.output_shapes[i]
+ else:
+ shape = tuple(self.context.get_binding_shape(idx))
+
+ output = torch.empty( # type: ignore[call-overload]
+ size=shape,
+ dtype=self.output_dtypes[i],
+ device=torch.cuda.current_device(),
+ )
+ outputs.append(output)
+ bindings[idx] = output.data_ptr()
+
+ for i, idx in enumerate(self.hidden_output_binding_indices_in_order):
+ if self.engine.has_implicit_batch_dimension:
+ shape = (batch_size,) + self.hidden_output_shapes[i]
+ else:
+ shape = tuple(self.context.get_binding_shape(idx))
+
+ output = torch.empty( # type: ignore[call-overload]
+ size=shape,
+ dtype=self.hidden_output_dtypes[i],
+ device=torch.cuda.current_device(),
+ )
+ bindings[idx] = output.data_ptr()
+
+ with torch.autograd.profiler.record_function("TRTModule:TensorRTRuntime"):
+ if self.engine.has_implicit_batch_dimension:
+ self.context.execute_async(
+ batch_size, bindings, torch.cuda.current_stream().cuda_stream
+ )
+ else:
+ self.context.execute_async_v2(
+ bindings, torch.cuda.current_stream().cuda_stream
+ )
+
+ if len(outputs) == 1:
+ return outputs[0]
+
+ return tuple(outputs)
+
+ def enable_profiling(self, profiler: "trt.IProfiler" = None):
+ """
+ Enable TensorRT profiling. After calling this function, TensorRT will report
+ time spent on each layer in stdout for each forward run.
+ """
+ self._check_initialized()
+
+ if not self.context.profiler:
+ self.context.profiler = trt.Profiler() if profiler is None else profiler
+
+ def disable_profiling(self):
+ """
+ Disable TensorRT profiling.
+ """
+ self._check_initialized()
+
+ torch.cuda.synchronize()
+ del self.context
+ self.context = self.engine.create_execution_context()
+
+ def get_layer_info(self) -> str:
+ """
+ Get layer info of the engine. Only support for TRT > 8.2.
+ """
+ inspector = self.engine.create_engine_inspector()
+ return inspector.get_engine_information(trt.LayerInformationFormat.JSON)
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from enum import Enum
+from torch_tensorrt._C import (
+ _get_logging_prefix,
+ _set_logging_prefix,
+ _get_reportable_log_level,
+ _set_reportable_log_level,
+ _get_is_colored_output_on,
+ _set_is_colored_output_on,
+ _log,
+ LogLevel,
+)
+
+
+[docs]class Level(Enum):
+ """Enum to set the minimum required logging level to print a message to stdout"""
+
+ InternalError = LogLevel.INTERNAL_ERROR
+ Error = LogLevel.ERROR
+ Warning = LogLevel.WARNING
+ Info = LogLevel.INFO
+ Debug = LogLevel.DEBUG
+ Graph = LogLevel.GRAPH
+
+ @staticmethod
+ def _to_internal_level(external) -> LogLevel:
+ if external == Level.InternalError:
+ return LogLevel.INTERNAL_ERROR
+ if external == Level.Error:
+ return LogLevel.ERROR
+ if external == Level.Warning:
+ return LogLevel.WARNING
+ if external == Level.Info:
+ return LogLevel.INFO
+ if external == Level.Debug:
+ return LogLevel.DEBUG
+ if external == Level.Graph:
+ return LogLevel.GRAPH
+
+
+[docs]def get_logging_prefix() -> str:
+ """Get the prefix set for logging messages
+
+ Returns:
+ str: Prefix used for logger
+ """
+ return _get_logging_prefix()
+
+
+[docs]def set_logging_prefix(prefix: str):
+ """Set the prefix used when logging messages
+
+ Args:
+ prefix (str): Prefix to use for logging messages
+ """
+ _set_logging_prefix(prefix)
+
+
+[docs]def get_reportable_log_level() -> Level:
+ """Get the level required for a message to be printed in the log
+
+ Returns:
+ torch_tensorrt.logging.Level: The enum representing the level required to print
+ """
+ return Level(_get_reportable_log_level())
+
+
+[docs]def set_reportable_log_level(level: Level):
+ """Set the level required for a message to be printed to the log
+
+ Args:
+ level (torch_tensorrt.logging.Level): The enum representing the level required to print
+ """
+ _set_reportable_log_level(Level._to_internal_level(level))
+
+
+[docs]def get_is_colored_output_on() -> bool:
+ """Get if colored output is enabled for logging
+
+ Returns:
+ bool: If colored output is one
+ """
+ return _get_is_colored_output_on()
+
+
+[docs]def set_is_colored_output_on(colored_output_on: bool):
+ """Enable or disable color in the log output
+
+ Args:
+ colored_output_on (bool): If colored output should be enabled or not
+ """
+ _set_is_colored_output_on(colored_output_on)
+
+
+[docs]def log(level: Level, msg: str):
+ """Add a new message to the log
+
+ Adds a new message to the log at a specified level. The message
+ will only get printed out if Level > reportable_log_level
+
+ Args:
+ level (torch_tensorrt.logging.Level): Severity of the message
+ msg (str): Actual message text
+ """
+ _log(Level._to_internal_level(level), msg)
+
+ InternalError = LogLevel.INTERNAL_ERROR
+ Error = LogLevel.ERROR
+ Warning = LogLevel.WARNING
+ Info = LogLevel.INFO
+ Debug = LogLevel.DEBUG
+ Graph = LogLevel.GRAPH
+
+
+[docs]class internal_errors:
+ """Context-manager to limit displayed log messages to just internal errors
+
+ Example::
+
+ with torch_tensorrt.logging.internal_errors():
+ outputs = model_torchtrt(inputs)
+ """
+
+ def __enter__(self):
+ self.external_lvl = get_reportable_log_level()
+ set_reportable_log_level(Level.InternalError)
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ set_reportable_log_level(self.external_lvl)
+
+
+[docs]class errors:
+ """Context-manager to limit displayed log messages to just errors and above
+
+ Example::
+
+ with torch_tensorrt.logging.errors():
+ outputs = model_torchtrt(inputs)
+ """
+
+ def __enter__(self):
+ self.external_lvl = get_reportable_log_level()
+ set_reportable_log_level(Level.Error)
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ set_reportable_log_level(self.external_lvl)
+
+
+[docs]class warnings:
+ """Context-manager to limit displayed log messages to just warnings and above
+
+ Example::
+
+ with torch_tensorrt.logging.warnings():
+ model_trt = torch_tensorrt.compile(model, **spec)
+ """
+
+ def __enter__(self):
+ self.external_lvl = get_reportable_log_level()
+ set_reportable_log_level(Level.Warning)
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ set_reportable_log_level(self.external_lvl)
+
+
+[docs]class info:
+ """Context-manager to display all info and greater severity messages
+
+ Example::
+
+ with torch_tensorrt.logging.info():
+ model_trt = torch_tensorrt.compile(model, **spec)
+ """
+
+ def __enter__(self):
+ self.external_lvl = get_reportable_log_level()
+ set_reportable_log_level(Level.Info)
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ set_reportable_log_level(self.external_lvl)
+
+
+[docs]class debug:
+ """Context-manager to display full debug information through the logger
+
+ Example::
+
+ with torch_tensorrt.logging.debug():
+ model_trt = torch_tensorrt.compile(model, **spec)
+ """
+
+ def __enter__(self):
+ self.external_lvl = get_reportable_log_level()
+ set_reportable_log_level(Level.Debug)
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ set_reportable_log_level(self.external_lvl)
+
+
+[docs]class graphs:
+ """Context-manager to display the results of intermediate lowering passes
+ as well as full debug information through the logger
+
+ Example::
+
+ with torch_tensorrt.logging.graphs():
+ model_trt = torch_tensorrt.compile(model, **spec)
+ """
+
+ def __enter__(self):
+ self.external_lvl = get_reportable_log_level()
+ set_reportable_log_level(Level.Graph)
+
+ def __exit__(self, exc_type, exc_value, exc_tb):
+ set_reportable_log_level(self.external_lvl)
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from typing import List, Dict, Any
+import torch
+import os
+
+from torch_tensorrt import _C
+from torch_tensorrt._version import __version__
+from torch_tensorrt.logging import *
+from types import FunctionType
+from enum import Enum
+
+
+[docs]class CalibrationAlgo(Enum):
+ ENTROPY_CALIBRATION = _C.CalibrationAlgo.ENTROPY_CALIBRATION
+ ENTROPY_CALIBRATION_2 = _C.CalibrationAlgo.ENTROPY_CALIBRATION_2
+ LEGACY_CALIBRATION = _C.CalibrationAlgo.LEGACY_CALIBRATION
+ MINMAX_CALIBRATION = _C.CalibrationAlgo.MINMAX_CALIBRATION
+
+
+
+
+
+
+
+
+[docs]def get_batch(self, names):
+ if self.current_batch_idx + self.batch_size > len(self.data_loader.dataset):
+ return None
+
+ batch = self.dataset_iterator.next()
+ self.current_batch_idx += self.batch_size
+ inputs_gpu = []
+ if isinstance(batch, list):
+ for example in batch:
+ inputs_gpu.append(example.to(self.device).data_ptr())
+ else:
+ inputs_gpu.append(batch.to(self.device).data_ptr())
+ return inputs_gpu
+
+
+[docs]def read_calibration_cache(self):
+ if self.cache_file and self.use_cache:
+ if os.path.exists(self.cache_file):
+ with open(self.cache_file, "rb") as f:
+ return f.read()
+ else:
+ return b""
+
+
+[docs]def write_calibration_cache(self, cache):
+ if self.cache_file:
+ with open(self.cache_file, "wb") as f:
+ f.write(cache)
+ else:
+ return b""
+
+
+[docs]class DataLoaderCalibrator(object):
+ """
+ Constructs a calibrator class in TensorRT and uses pytorch dataloader to load/preproces
+ data which is passed during calibration.
+ Args:
+ dataloader: an instance of pytorch dataloader which iterates through a given dataset.
+ algo_type: choice of calibration algorithm.
+ cache_file: path to cache file.
+ use_cache: flag which enables usage of pre-existing cache.
+ device: device on which calibration data is copied to.
+ """
+
+
+
+ def __new__(cls, *args, **kwargs):
+ dataloader = args[0]
+ algo_type = kwargs.get("algo_type", CalibrationAlgo.ENTROPY_CALIBRATION_2)
+ cache_file = kwargs.get("cache_file", None)
+ use_cache = kwargs.get("use_cache", False)
+ device = kwargs.get("device", torch.device("cuda:0"))
+
+ if not isinstance(dataloader, torch.utils.data.DataLoader):
+ log(
+ Level.Error,
+ "Dataloader : {} is not a valid instance of torch.utils.data.DataLoader".format(
+ dataloader
+ ),
+ )
+
+ if not cache_file:
+ if use_cache:
+ log(
+ Level.Debug,
+ "Using existing cache_file {} for calibration".format(cache_file),
+ )
+ else:
+ log(Level.Debug, "Overwriting existing calibration cache file.")
+ else:
+ if use_cache:
+ log(
+ Level.Error,
+ "Input cache file is None but use_cache is set to True in INT8 mode.",
+ )
+
+ # Define attributes and member functions for the calibrator class
+ attribute_mapping = {
+ "data_loader": dataloader,
+ "current_batch_idx": 0,
+ "batch_size": dataloader.batch_size,
+ "dataset_iterator": iter(dataloader),
+ "cache_file": cache_file,
+ "device": device,
+ "use_cache": use_cache,
+ "get_batch_size": get_batch_size,
+ "get_batch": get_cache_mode_batch if use_cache else get_batch,
+ "read_calibration_cache": read_calibration_cache,
+ "write_calibration_cache": write_calibration_cache,
+ }
+
+ # Using type metaclass to construct calibrator class based on algorithm type
+ if algo_type == CalibrationAlgo.ENTROPY_CALIBRATION:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8EntropyCalibrator,), attribute_mapping
+ )()
+ elif algo_type == CalibrationAlgo.ENTROPY_CALIBRATION_2:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8MinMaxCalibrator,), attribute_mapping
+ )()
+ elif algo_type == CalibrationAlgo.LEGACY_CALIBRATION:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8LegacyCalibrator,), attribute_mapping
+ )()
+ elif algo_type == CalibrationAlgo.MINMAX_CALIBRATION:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8MinMaxCalibrator,), attribute_mapping
+ )()
+ else:
+ log(
+ Level.Error,
+ "Invalid calibration algorithm type. Please select among ENTROPY_CALIBRATION, ENTROPY_CALIBRATION, LEGACY_CALIBRATION or MINMAX_CALIBRATION",
+ )
+
+
+[docs]class CacheCalibrator(object):
+ """
+ Constructs a calibrator class in TensorRT which directly uses pre-existing cache file for calibration.
+ Args:
+ cache_file: path to cache file.
+ algo_type: choice of calibration algorithm.
+ """
+
+
+
+ def __new__(cls, *args, **kwargs):
+ cache_file = args[0]
+ algo_type = kwargs.get("algo_type", CalibrationAlgo.ENTROPY_CALIBRATION_2)
+
+ if os.path.isfile(cache_file):
+ log(
+ Level.Debug,
+ "Using existing cache_file {} for calibration".format(cache_file),
+ )
+ else:
+ log(Level.Error, "Invalid calibration cache file.")
+
+ # Define attributes and member functions for the calibrator class
+ attribute_mapping = {
+ "use_cache": True,
+ "cache_file": cache_file,
+ "get_batch_size": get_batch_size,
+ "get_batch": get_cache_mode_batch,
+ "read_calibration_cache": read_calibration_cache,
+ "write_calibration_cache": write_calibration_cache,
+ }
+ # Using type metaclass to construct calibrator class based on algorithm type
+ if algo_type == CalibrationAlgo.ENTROPY_CALIBRATION:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8EntropyCalibrator,), attribute_mapping
+ )()
+ elif algo_type == CalibrationAlgo.ENTROPY_CALIBRATION_2:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8MinMaxCalibrator,), attribute_mapping
+ )()
+ elif algo_type == CalibrationAlgo.LEGACY_CALIBRATION:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8LegacyCalibrator,), attribute_mapping
+ )()
+ elif algo_type == CalibrationAlgo.MINMAX_CALIBRATION:
+ return type(
+ "DataLoaderCalibrator", (_C.IInt8MinMaxCalibrator,), attribute_mapping
+ )()
+ else:
+ log(
+ Level.Error,
+ "Invalid calibration algorithm type. Please select among ENTROPY_CALIBRATION, ENTROPY_CALIBRATION, LEGACY_CALIBRATION or MINMAX_CALIBRATION",
+ )
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from typing import List, Dict, Any, Set
+import torch
+from torch_tensorrt import _C
+import torch_tensorrt._C.ts as _ts_C
+from torch_tensorrt import _enums
+from torch_tensorrt._Input import Input
+from torch_tensorrt._Device import Device
+from torch_tensorrt.logging import Level, log
+from typing import Tuple, List, Dict
+import warnings
+from copy import deepcopy
+
+
+def _internal_input_to_torch_class_input(i: _C.Input) -> torch.classes.tensorrt._Input:
+ clone = torch.classes.tensorrt._Input()
+ clone._set_min(i.min)
+ clone._set_opt(i.opt)
+ clone._set_max(i.max)
+ clone._set_dtype(i.dtype)
+ clone._set_format(i.format)
+ clone._set_input_is_dynamic(i.input_is_dynamic)
+ clone._set_explicit_set_dtype(i._explicit_set_dtype)
+ return clone
+
+
+def _supported_input_size_type(input_size: Any) -> bool:
+ if isinstance(input_size, torch.Size):
+ return True
+ elif isinstance(input_size, tuple):
+ return True
+ elif isinstance(input_size, list):
+ return True
+ else:
+ raise TypeError(
+ "Input sizes for inputs are required to be a List, tuple or torch.Size or a Dict of three sizes (min, opt, max), found type: "
+ + str(type(input_size))
+ )
+
+
+def _parse_input_ranges(input_sizes: List) -> List:
+
+ if any(
+ not isinstance(i, dict) and not _supported_input_size_type(i)
+ for i in input_sizes
+ ):
+ raise KeyError(
+ "An input size must either be a static size or a range of three sizes (min, opt, max) as Dict"
+ )
+
+ parsed_input_sizes = []
+ for i in input_sizes:
+ if isinstance(i, dict):
+ if all(k in i for k in ["min", "opt", "min"]):
+ parsed_input_sizes.append(
+ Input(
+ min_shape=i["min"], opt_shape=i["opt"], max_shape=i["max"]
+ )._to_internal()
+ )
+
+ elif "opt" in i:
+ parsed_input_sizes.append(Input(shape=i["opt"])._to_internal())
+
+ else:
+ raise KeyError(
+ "An input size must either be a static size or a range of three sizes (min, opt, max) as Dict"
+ )
+
+ elif isinstance(i, list):
+ parsed_input_sizes.append(Input(shape=i)._to_internal())
+
+ elif isinstance(i, tuple):
+ parsed_input_sizes.append(Input(shape=i)._to_internal())
+
+ elif isinstance(i, torch.Size):
+ parsed_input_sizes.append(Input(shape=i)._to_internal())
+
+ return parsed_input_sizes
+
+
+def _parse_op_precision(precision: Any) -> _enums.dtype:
+ if isinstance(precision, torch.dtype):
+ if precision == torch.int8:
+ return _enums.dtype.int8
+ elif precision == torch.half:
+ return _enums.dtype.half
+ elif precision == torch.float:
+ return _enums.dtype.float
+ else:
+ raise TypeError(
+ "Provided an unsupported dtype as operating precision (support: int8, half, float), got: "
+ + str(precision)
+ )
+
+ elif isinstance(precision, _enums.dtype):
+ return precision
+
+ else:
+ raise TypeError(
+ "Op precision type needs to be specified with a torch.dtype or a torch_tensorrt.dtype, got: "
+ + str(type(precision))
+ )
+
+
+def _parse_enabled_precisions(precisions: Any) -> Set:
+ parsed_precisions = set()
+ if any([isinstance(precisions, type) for type in [list, tuple, set]]):
+ for p in precisions:
+ parsed_precisions.add(_parse_op_precision(p))
+ else:
+ parsed_precisions.add(_parse_op_precision(precisions))
+ return parsed_precisions
+
+
+def _parse_device_type(device: Any) -> _enums.DeviceType:
+ if isinstance(device, torch.device):
+ if device.type == "cuda":
+ return _enums.DeviceType.gpu
+ else:
+ ValueError(
+ "Got a device type other than GPU or DLA (type: "
+ + str(device.type)
+ + ")"
+ )
+ elif isinstance(device, _enums.DeviceType):
+ return device
+ elif isinstance(device, str):
+ if device == "gpu" or device == "GPU":
+ return _enums.DeviceType.gpu
+ elif device == "dla" or device == "DLA":
+ return _enums.DeviceType.dla
+ else:
+ ValueError(
+ "Got a device type other than GPU or DLA (type: " + str(device) + ")"
+ )
+ else:
+ raise TypeError(
+ "Device specification must be of type torch.device, string or torch_tensorrt.DeviceType, but got: "
+ + str(type(device))
+ )
+
+
+def _parse_device(device_info: Any) -> _C.Device:
+ if isinstance(device_info, dict):
+ info = _C.Device()
+ if "device_type" not in device_info:
+ raise KeyError("Device type is required parameter")
+ else:
+ assert isinstance(device_info["device_type"], _enums.DeviceType)
+ info.device_type = _parse_device_type(device_info["device_type"])
+
+ if "gpu_id" in device_info:
+ assert isinstance(device_info["gpu_id"], int)
+ info.gpu_id = device_info["gpu_id"]
+
+ if "dla_core" in device_info:
+ assert isinstance(device_info["dla_core"], int)
+ info.dla_core = device_info["dla_core"]
+
+ if "allow_gpu_fallback" in device_info:
+ assert isinstance(device_info["allow_gpu_fallback"], bool)
+ info.allow_gpu_fallback = device_info["allow_gpu_fallback"]
+
+ return info
+ elif isinstance(device_info, Device):
+ return device_info._to_internal()
+ elif isinstance(device_info, torch.device):
+ return (Device._from_torch_device(device_info))._to_internal()
+ else:
+ raise ValueError(
+ "Unsupported data for device specification. Expected either a dict, torch_tensorrt.Device or torch.Device"
+ )
+
+
+def _parse_torch_fallback(fallback_info: Dict[str, Any]) -> _ts_C.TorchFallback:
+ info = _ts_C.TorchFallback()
+ if "enabled" not in fallback_info:
+ raise KeyError("Enabled is required parameter")
+ else:
+ assert isinstance(fallback_info["enabled"], bool)
+ info.enabled = fallback_info["enabled"]
+ if "min_block_size" in fallback_info:
+ assert isinstance(fallback_info["min_block_size"], int)
+ info.min_block_size = fallback_info["min_block_size"]
+
+ if "forced_fallback_ops" in fallback_info:
+ assert isinstance(fallback_info["forced_fallback_ops"], list)
+ info.forced_fallback_operators = fallback_info["forced_fallback_ops"]
+
+ if "forced_fallback_modules" in fallback_info:
+ assert isinstance(fallback_info["forced_fallback_modules"], list)
+ info.forced_fallback_modules = fallback_info["forced_fallback_modules"]
+
+ return info
+
+
+def _parse_input_signature(input_signature: Any):
+ if isinstance(input_signature, tuple):
+ input_list = []
+ for item in input_signature:
+ input = _parse_input_signature(item)
+ input_list.append(input)
+ return tuple(input_list)
+ elif isinstance(input_signature, list):
+ input_list = []
+ for item in input_signature:
+ input = _parse_input_signature(item)
+ input_list.append(input)
+ return input_list
+ elif isinstance(input_signature, Input) or isinstance(
+ input_signature, torch.Tensor
+ ):
+ i = (
+ Input._from_tensor(input_signature)
+ if isinstance(input_signature, torch.Tensor)
+ else input_signature
+ )
+ clone = _internal_input_to_torch_class_input(i._to_internal())
+ return clone
+ else:
+ raise KeyError(
+ "Input signature contains an unsupported type {}".format(
+ type(input_signature)
+ )
+ )
+
+
+def _parse_compile_spec(compile_spec_: Dict[str, Any]) -> _ts_C.CompileSpec:
+ # TODO: Remove deep copy once collections does not need partial compilation
+ compile_spec = deepcopy(compile_spec_)
+ info = _ts_C.CompileSpec()
+
+ if len(compile_spec["inputs"]) > 0:
+ if not all(
+ [
+ isinstance(i, torch.Tensor) or isinstance(i, Input)
+ for i in compile_spec["inputs"]
+ ]
+ ):
+ raise KeyError(
+ "Input specs should be either torch_tensorrt.Input or torch.Tensor, found types: {}".format(
+ [type(i) for i in compile_spec["inputs"]]
+ )
+ )
+
+ inputs = [
+ Input._from_tensor(i) if isinstance(i, torch.Tensor) else i
+ for i in compile_spec["inputs"]
+ ]
+ info.inputs = [i._to_internal() for i in inputs]
+
+ elif compile_spec["input_signature"] is not None:
+ log(
+ Level.Warning,
+ "Input signature parsing is an experimental feature, behavior and APIs may change",
+ )
+ signature = _parse_input_signature(compile_spec["input_signature"])
+ info.input_signature = _C.InputSignature(signature) # py_object
+
+ if not compile_spec["torch_fallback"]["enabled"]:
+ raise ValueError(
+ "Grouped inputs currently requires partial compilation to be enabled, this restriction will be relaxed in a future release"
+ )
+
+ log(
+ Level.Debug,
+ "Grouped inputs currently requires additional settings to enable the feature",
+ )
+ log(
+ Level.Debug,
+ """Adding the following ops to torch_executed_ops:
+ - aten::__getitem__
+ - prim::ListConstruct
+ - prim::ListUnpack
+ - prim::TupleIndex
+ - prim::TupleConstruct
+ - prim::TupleUnpack
+""",
+ )
+ compile_spec["torch_fallback"]["forced_fallback_ops"].append(
+ "aten::__getitem__"
+ )
+ compile_spec["torch_fallback"]["forced_fallback_ops"].append(
+ "prim::ListConstruct"
+ )
+ compile_spec["torch_fallback"]["forced_fallback_ops"].append("prim::ListUnpack")
+ compile_spec["torch_fallback"]["forced_fallback_ops"].append("prim::TupleIndex")
+ compile_spec["torch_fallback"]["forced_fallback_ops"].append(
+ "prim::TupleConstruct"
+ )
+ compile_spec["torch_fallback"]["forced_fallback_ops"].append(
+ "prim::TupleUnpack"
+ )
+
+ else:
+ raise KeyError(
+ 'Module input definitions are requried to compile module. Provide a list of torch_tensorrt.Input keyed to "inputs" in the compile spec'
+ )
+
+ if "enabled_precisions" in compile_spec:
+ info.enabled_precisions = _parse_enabled_precisions(
+ compile_spec["enabled_precisions"]
+ )
+
+ if "calibrator" in compile_spec:
+ info.ptq_calibrator = compile_spec["calibrator"]
+
+ if "sparse_weights" in compile_spec:
+ assert isinstance(compile_spec["sparse_weights"], bool)
+ info.sparse_weights = compile_spec["sparse_weights"]
+
+ if "disable_tf32" in compile_spec:
+ assert isinstance(compile_spec["disable_tf32"], bool)
+ info.disable_tf32 = compile_spec["disable_tf32"]
+
+ if "refit" in compile_spec:
+ assert isinstance(compile_spec["refit"], bool)
+ info.refit = compile_spec["refit"]
+
+ if "debug" in compile_spec:
+ assert isinstance(compile_spec["debug"], bool)
+ info.debug = compile_spec["debug"]
+
+ if "device" in compile_spec:
+ info.device = _parse_device(compile_spec["device"])
+
+ if "capability" in compile_spec:
+ assert isinstance(compile_spec["capability"], _enums.EngineCapability)
+ info.capability = compile_spec["capability"]
+
+ if "num_avg_timing_iters" in compile_spec:
+ assert type(compile_spec["num_avg_timing_iters"]) is int
+ info.num_avg_timing_iters = compile_spec["num_avg_timing_iters"]
+
+ if "workspace_size" in compile_spec:
+ assert type(compile_spec["workspace_size"]) is int
+ info.workspace_size = compile_spec["workspace_size"]
+
+ if "dla_sram_size" in compile_spec:
+ assert type(compile_spec["dla_sram_size"]) is int
+ info.dla_sram_size = compile_spec["dla_sram_size"]
+
+ if "dla_local_dram_size" in compile_spec:
+ assert type(compile_spec["dla_local_dram_size"]) is int
+ info.dla_local_dram_size = compile_spec["dla_local_dram_size"]
+
+ if "dla_global_dram_size" in compile_spec:
+ assert type(compile_spec["dla_global_dram_size"]) is int
+ info.dla_global_dram_size = compile_spec["dla_global_dram_size"]
+
+ if "truncate_long_and_double" in compile_spec:
+ assert type(compile_spec["truncate_long_and_double"]) is bool
+ info.truncate_long_and_double = compile_spec["truncate_long_and_double"]
+
+ if "torch_fallback" in compile_spec:
+ info.torch_fallback = _parse_torch_fallback(compile_spec["torch_fallback"])
+
+ log(Level.Debug, str(info))
+
+ return info
+
+
+[docs]def TensorRTCompileSpec(
+ inputs=[],
+ input_signature=None,
+ device=Device._current_device(),
+ disable_tf32=False,
+ sparse_weights=False,
+ enabled_precisions=set(),
+ refit=False,
+ debug=False,
+ capability=_enums.EngineCapability.default,
+ num_avg_timing_iters=1,
+ workspace_size=0,
+ dla_sram_size=1048576,
+ dla_local_dram_size=1073741824,
+ dla_global_dram_size=536870912,
+ truncate_long_and_double=False,
+ calibrator=None,
+) -> torch.classes.tensorrt.CompileSpec:
+ """Utility to create a formated spec dictionary for using the PyTorch TensorRT backend
+
+ Keyword Args:
+ inputs (List[Union(torch_tensorrt.Input, torch.Tensor)]): **Required** List of specifications of input shape, dtype and memory layout for inputs to the module. This argument is required. Input Sizes can be specified as torch sizes, tuples or lists. dtypes can be specified using
+ torch datatypes or torch_tensorrt datatypes and you can use either torch devices or the torch_tensorrt device type enum
+ to select device type. ::
+
+ input=[
+ torch_tensorrt.Input((1, 3, 224, 224)), # Static NCHW input shape for input #1
+ torch_tensorrt.Input(
+ min_shape=(1, 224, 224, 3),
+ opt_shape=(1, 512, 512, 3),
+ max_shape=(1, 1024, 1024, 3),
+ dtype=torch.int32
+ format=torch.channel_last
+ ), # Dynamic input shape for input #2
+ torch.randn((1, 3, 224, 244)) # Use an example tensor and let torch_tensorrt infer settings
+ ]
+
+ device (Union(torch_tensorrt.Device, torch.device, dict)): Target device for TensorRT engines to run on ::
+
+ device=torch_tensorrt.Device("dla:1", allow_gpu_fallback=True)
+
+ disable_tf32 (bool): Force FP32 layers to use traditional as FP32 format vs the default behavior of rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas
+ sparse_weights (bool): Enable sparsity for convolution and fully connected layers.
+ enabled_precision (Set(Union(torch.dtype, torch_tensorrt.dtype))): The set of datatypes that TensorRT can use when selecting kernels
+ refit (bool): Enable refitting
+ debug (bool): Enable debuggable engine
+ capability (torch_tensorrt.EngineCapability): Restrict kernel selection to safe gpu kernels or safe dla kernels
+ num_avg_timing_iters (int): Number of averaging timing iterations used to select kernels
+ workspace_size (int): Maximum size of workspace given to TensorRT
+ truncate_long_and_double (bool): Truncate weights provided in int64 or double (float64) to int32 and float32
+ calibrator (Union(torch_tensorrt._C.IInt8Calibrator, tensorrt.IInt8Calibrator)): Calibrator object which will provide data to the PTQ system for INT8 Calibration
+
+ Returns:
+ torch.classes.tensorrt.CompileSpec: List of methods and formated spec objects to be provided to ``torch._C._jit_to_tensorrt``
+ """
+
+ compile_spec = {
+ "inputs": inputs,
+ # "input_signature": input_signature,
+ "device": device,
+ "disable_tf32": disable_tf32, # Force FP32 layers to use traditional as FP32 format vs the default behavior of rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas
+ "sparse_weights": sparse_weights, # Enable sparsity for convolution and fully connected layers.
+ "enabled_precisions": enabled_precisions, # Enabling FP16 kernels
+ "refit": refit, # enable refit
+ "debug": debug, # enable debuggable engine
+ "capability": capability, # Restrict kernel selection to safe gpu kernels or safe dla kernels
+ "num_avg_timing_iters": num_avg_timing_iters, # Number of averaging timing iterations used to select kernels
+ "workspace_size": workspace_size, # Maximum size of workspace given to TensorRT
+ "dla_sram_size": dla_sram_size, # Fast software managed RAM used by DLA to communicate within a layer.
+ "dla_local_dram_size": dla_local_dram_size, # Host RAM used by DLA to share intermediate tensor data across operations
+ "dla_global_dram_size": dla_global_dram_size, # Host RAM used by DLA to store weights and metadata for execution
+ "calibrator": calibrator,
+ "truncate_long_and_double": truncate_long_and_double,
+ }
+
+ parsed_spec = _parse_compile_spec(compile_spec)
+
+ backend_spec = torch.classes.tensorrt.CompileSpec()
+
+ if input_signature is not None:
+ raise ValueError(
+ "Input signature parsing is not currently supported in the TorchScript backend integration"
+ )
+
+ for i in parsed_spec.inputs:
+ clone = _internal_input_to_torch_class_input(i)
+ backend_spec._append_input(clone)
+
+ d = torch.classes.tensorrt._Device()
+ d._set_device_type(int(parsed_spec.device.device_type))
+ d._set_gpu_id(parsed_spec.device.gpu_id)
+ d._set_dla_core(parsed_spec.device.dla_core)
+ d._set_allow_gpu_fallback(parsed_spec.device.allow_gpu_fallback)
+
+ if parsed_spec.torch_fallback.enabled:
+ raise RuntimeError(
+ "Partial module compilation is not currently supported via the PyTorch TensorRT backend. If you need partial compilation, use torch_tensorrt.compile"
+ )
+
+ torch_fallback = torch.classes.tensorrt._TorchFallback()
+ torch_fallback._set_enabled(parsed_spec.torch_fallback.enabled)
+ torch_fallback._set_min_block_size(parsed_spec.torch_fallback.min_block_size)
+ torch_fallback._set_forced_fallback_operators(
+ parsed_spec.torch_fallback.forced_fallback_operators
+ )
+ torch_fallback._set_forced_fallback_modules(
+ parsed_spec.torch_fallback.forced_fallback_modules
+ )
+
+ backend_spec._set_device(d)
+ backend_spec._set_torch_fallback(torch_fallback)
+ backend_spec._set_precisions([int(i) for i in parsed_spec.enabled_precisions])
+
+ backend_spec._set_disable_tf32(parsed_spec.disable_tf32)
+ backend_spec._set_refit(parsed_spec.refit)
+ backend_spec._set_debug(parsed_spec.debug)
+ backend_spec._set_refit(parsed_spec.refit)
+ backend_spec._set_capability(int(parsed_spec.capability))
+ backend_spec._set_num_avg_timing_iters(parsed_spec.num_avg_timing_iters)
+ backend_spec._set_workspace_size(parsed_spec.workspace_size)
+ backend_spec._set_dla_sram_size(parsed_spec.dla_sram_size)
+ backend_spec._set_dla_local_dram_size(parsed_spec.dla_local_dram_size)
+ backend_spec._set_dla_global_dram_size(parsed_spec.dla_global_dram_size)
+ backend_spec._set_truncate_long_and_double(parsed_spec.truncate_long_and_double)
+ backend_spec._set_ptq_calibrator(parsed_spec._get_calibrator_handle())
+
+ return backend_spec
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+
+from typing import List, Dict, Any
+import torch
+from torch import nn
+
+import torch_tensorrt._C.ts as _C
+from torch_tensorrt import _enums
+from torch_tensorrt.ts._compile_spec import _parse_compile_spec, _parse_device
+from torch_tensorrt._Device import Device
+from types import FunctionType
+
+
+[docs]def compile(
+ module: torch.jit.ScriptModule,
+ inputs=[],
+ input_signature=None,
+ device=Device._current_device(),
+ disable_tf32=False,
+ sparse_weights=False,
+ enabled_precisions=set(),
+ refit=False,
+ debug=False,
+ capability=_enums.EngineCapability.default,
+ num_avg_timing_iters=1,
+ workspace_size=0,
+ dla_sram_size=1048576,
+ dla_local_dram_size=1073741824,
+ dla_global_dram_size=536870912,
+ calibrator=None,
+ truncate_long_and_double=False,
+ require_full_compilation=False,
+ min_block_size=3,
+ torch_executed_ops=[],
+ torch_executed_modules=[],
+) -> torch.jit.ScriptModule:
+ """Compile a TorchScript module for NVIDIA GPUs using TensorRT
+
+ Takes a existing TorchScript module and a set of settings to configure the compiler
+ and will convert methods to JIT Graphs which call equivalent TensorRT engines
+
+ Converts specifically the forward method of a TorchScript Module
+
+ Arguments:
+ module (torch.jit.ScriptModule): Source module, a result of tracing or scripting a PyTorch
+ ``torch.nn.Module``
+
+ Keyword Arguments:
+ inputs (List[Union(torch_tensorrt.Input, torch.Tensor)]): **Required** List of specifications of input shape, dtype and memory layout for inputs to the module. This argument is required. Input Sizes can be specified as torch sizes, tuples or lists. dtypes can be specified using
+ torch datatypes or torch_tensorrt datatypes and you can use either torch devices or the torch_tensorrt device type enum
+ to select device type. ::
+
+ input=[
+ torch_tensorrt.Input((1, 3, 224, 224)), # Static NCHW input shape for input #1
+ torch_tensorrt.Input(
+ min_shape=(1, 224, 224, 3),
+ opt_shape=(1, 512, 512, 3),
+ max_shape=(1, 1024, 1024, 3),
+ dtype=torch.int32
+ format=torch.channel_last
+ ), # Dynamic input shape for input #2
+ torch.randn((1, 3, 224, 244)) # Use an example tensor and let torch_tensorrt infer settings
+ ]
+
+ input_signature Union(List, Tuple, torch_tensorrt.Input, torch.Tensor): A formatted collection of input specifications for the module. Input Sizes can be specified as torch sizes, tuples or lists. dtypes can be specified using
+ torch datatypes or torch_tensorrt datatypes and you can use either torch devices or the torch_tensorrt device type enum to select device type. **This API should be considered beta-level stable and may change in the future** ::
+
+ input_signature=([
+ torch_tensorrt.Input((1, 3, 224, 224)), # Static NCHW input shape for input #1
+ torch_tensorrt.Input(
+ min_shape=(1, 224, 224, 3),
+ opt_shape=(1, 512, 512, 3),
+ max_shape=(1, 1024, 1024, 3),
+ dtype=torch.int32
+ format=torch.channel_last
+ ), # Dynamic input shape for input #2
+ ], torch.randn((1, 3, 224, 244))) # Use an example tensor and let torch_tensorrt infer settings for input #3
+ device (Union(torch_tensorrt.Device, torch.device, dict)): Target device for TensorRT engines to run on ::
+
+ device=torch_tensorrt.Device("dla:1", allow_gpu_fallback=True)
+
+ disable_tf32 (bool): Force FP32 layers to use traditional as FP32 format vs the default behavior of rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas
+ sparse_weights (bool): Enable sparsity for convolution and fully connected layers.
+ enabled_precision (Set(Union(torch.dtype, torch_tensorrt.dtype))): The set of datatypes that TensorRT can use when selecting kernels
+ refit (bool): Enable refitting
+ debug (bool): Enable debuggable engine
+ capability (torch_tensorrt.EngineCapability): Restrict kernel selection to safe gpu kernels or safe dla kernels
+ num_avg_timing_iters (int): Number of averaging timing iterations used to select kernels
+ workspace_size (int): Maximum size of workspace given to TensorRT
+ dla_sram_size (int): Fast software managed RAM used by DLA to communicate within a layer.
+ dla_local_dram_size (int): Host RAM used by DLA to share intermediate tensor data across operations
+ dla_global_dram_size (int): Host RAM used by DLA to store weights and metadata for execution
+ truncate_long_and_double (bool): Truncate weights provided in int64 or double (float64) to int32 and float32
+ calibrator (Union(torch_tensorrt._C.IInt8Calibrator, tensorrt.IInt8Calibrator)): Calibrator object which will provide data to the PTQ system for INT8 Calibration
+ require_full_compilation (bool): Require modules to be compiled end to end or return an error as opposed to returning a hybrid graph where operations that cannot be run in TensorRT are run in PyTorch
+ min_block_size (int): The minimum number of contiguous TensorRT convertable operations in order to run a set of operations in TensorRT
+ torch_executed_ops (List[str]): List of aten operators that must be run in PyTorch. An error will be thrown if this list is not empty but ``require_full_compilation`` is True
+ torch_executed_modules (List[str]): List of modules that must be run in PyTorch. An error will be thrown if this list is not empty but ``require_full_compilation`` is True
+
+ Returns:
+ torch.jit.ScriptModule: Compiled TorchScript Module, when run it will execute via TensorRT
+ """
+
+ if isinstance(module, torch.jit.ScriptFunction):
+ raise TypeError(
+ "torch.jit.ScriptFunction currently is not directly supported, wrap the function in a module to compile"
+ )
+
+ if require_full_compilation and (
+ len(torch_executed_modules) > 0 or len(torch_executed_ops) > 0
+ ):
+ raise ValueError(
+ f"require_full_compilation is enabled however the list of modules and ops to run in torch is not empty. Found: torch_executed_ops: {torch_executed_ops}, torch_executed_modules: {torch_executed_modules}"
+ )
+
+ spec = {
+ "inputs": inputs,
+ "input_signature": input_signature,
+ "device": device,
+ "disable_tf32": disable_tf32, # Force FP32 layers to use traditional as FP32 format
+ "sparse_weights": sparse_weights, # Enable sparsity for convolution and fully connected layers.
+ "enabled_precisions": enabled_precisions, # Enabling FP16 kernels
+ "refit": refit, # enable refit
+ "debug": debug, # enable debuggable engine
+ "capability": capability, # Restrict kernel selection to safe gpu kernels or safe dla kernels
+ "num_avg_timing_iters": num_avg_timing_iters, # Number of averaging timing iterations used to select kernels
+ "workspace_size": workspace_size, # Maximum size of workspace given to TensorRT
+ "calibrator": calibrator,
+ "truncate_long_and_double": truncate_long_and_double,
+ "torch_fallback": {
+ "enabled": not require_full_compilation,
+ "forced_fallback_ops": torch_executed_ops,
+ "forced_fallback_modules": torch_executed_modules,
+ "min_block_size": min_block_size,
+ },
+ }
+
+ compiled_cpp_mod = _C.compile_graph(module._c, _parse_compile_spec(spec))
+ compiled_module = torch.jit._recursive.wrap_cpp_module(compiled_cpp_mod)
+ return compiled_module
+
+
+[docs]def convert_method_to_trt_engine(
+ module: torch.jit.ScriptModule,
+ method_name: str,
+ inputs=[],
+ device=Device._current_device(),
+ disable_tf32=False,
+ sparse_weights=False,
+ enabled_precisions=set(),
+ refit=False,
+ debug=False,
+ capability=_enums.EngineCapability.default,
+ num_avg_timing_iters=1,
+ workspace_size=0,
+ dla_sram_size=1048576,
+ dla_local_dram_size=1073741824,
+ dla_global_dram_size=536870912,
+ truncate_long_and_double=False,
+ calibrator=None,
+) -> str:
+ """Convert a TorchScript module method to a serialized TensorRT engine
+
+ Converts a specified method of a module to a serialized TensorRT engine given a dictionary of conversion settings
+
+ Arguments:
+ module (torch.jit.ScriptModule): Source module, a result of tracing or scripting a PyTorch
+ ``torch.nn.Module``
+ method_name (str): Name of method to convert
+
+ Keyword Args:
+ inputs (List[Union(torch_tensorrt.Input, torch.Tensor)]): **Required** List of specifications of input shape, dtype and memory layout for inputs to the module. This argument is required. Input Sizes can be specified as torch sizes, tuples or lists. dtypes can be specified using
+ torch datatypes or torch_tensorrt datatypes and you can use either torch devices or the torch_tensorrt device type enum
+ to select device type. ::
+
+ input=[
+ torch_tensorrt.Input((1, 3, 224, 224)), # Static NCHW input shape for input #1
+ torch_tensorrt.Input(
+ min_shape=(1, 224, 224, 3),
+ opt_shape=(1, 512, 512, 3),
+ max_shape=(1, 1024, 1024, 3),
+ dtype=torch.int32
+ format=torch.channel_last
+ ), # Dynamic input shape for input #2
+ torch.randn((1, 3, 224, 244)) # Use an example tensor and let torch_tensorrt infer settings
+ ]
+
+ input_signature Union(List, Tuple, torch_tensorrt.Input, torch.Tensor): A formatted collection of input specifications for the module. Input Sizes can be specified as torch sizes, tuples or lists. dtypes can be specified using
+ torch datatypes or torch_tensorrt datatypes and you can use either torch devices or the torch_tensorrt device type enum to select device type. **This API should be considered beta-level stable and may change in the future** ::
+
+ input_signature=([
+ torch_tensorrt.Input((1, 3, 224, 224)), # Static NCHW input shape for input #1
+ torch_tensorrt.Input(
+ min_shape=(1, 224, 224, 3),
+ opt_shape=(1, 512, 512, 3),
+ max_shape=(1, 1024, 1024, 3),
+ dtype=torch.int32
+ format=torch.channel_last
+ ), # Dynamic input shape for input #2
+ ], torch.randn((1, 3, 224, 244))) # Use an example tensor and let torch_tensorrt infer settings for input #3
+
+ device (Union(torch_tensorrt.Device, torch.device, dict)): Target device for TensorRT engines to run on ::
+
+ device=torch_tensorrt.Device("dla:1", allow_gpu_fallback=True)
+
+ disable_tf32 (bool): Force FP32 layers to use traditional as FP32 format vs the default behavior of rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas
+ sparse_weights (bool): Enable sparsity for convolution and fully connected layers.
+ enabled_precision (Set(Union(torch.dtype, torch_tensorrt.dtype))): The set of datatypes that TensorRT can use when selecting kernels
+ refit (bool): Enable refitting
+ debug (bool): Enable debuggable engine
+ capability (torch_tensorrt.EngineCapability): Restrict kernel selection to safe gpu kernels or safe dla kernels
+ num_avg_timing_iters (int): Number of averaging timing iterations used to select kernels
+ workspace_size (int): Maximum size of workspace given to TensorRT
+ dla_sram_size (int): Fast software managed RAM used by DLA to communicate within a layer.
+ dla_local_dram_size (int): Host RAM used by DLA to share intermediate tensor data across operations
+ dla_global_dram_size (int): Host RAM used by DLA to store weights and metadata for execution
+ truncate_long_and_double (bool): Truncate weights provided in int64 or double (float64) to int32 and float32
+ calibrator (Union(torch_tensorrt._C.IInt8Calibrator, tensorrt.IInt8Calibrator)): Calibrator object which will provide data to the PTQ system for INT8 Calibration
+
+ Returns:
+ bytes: Serialized TensorRT engine, can either be saved to a file or deserialized via TensorRT APIs
+ """
+ if isinstance(module, torch.jit.ScriptFunction):
+ raise TypeError(
+ "torch.jit.ScriptFunctions currently are not directly supported, wrap the function in a module to compile"
+ )
+
+ compile_spec = {
+ "inputs": inputs,
+ "device": device,
+ "disable_tf32": disable_tf32, # Force FP32 layers to use traditional as FP32 format vs the default behavior of rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas
+ "sparse_weights": sparse_weights, # Enable sparsity for convolution and fully connected layers.
+ "enabled_precisions": enabled_precisions, # Enabling FP16 kernels
+ "refit": refit, # enable refit
+ "debug": debug, # enable debuggable engine
+ "capability": capability, # Restrict kernel selection to safe gpu kernels or safe dla kernels
+ "num_avg_timing_iters": num_avg_timing_iters, # Number of averaging timing iterations used to select kernels
+ "workspace_size": workspace_size, # Maximum size of workspace given to TensorRT
+ "calibrator": calibrator,
+ "truncate_long_and_double": truncate_long_and_double,
+ }
+
+ return _C.convert_graph_to_trt_engine(
+ module._c, method_name, _parse_compile_spec(compile_spec)
+ )
+
+
+[docs]def embed_engine_in_new_module(
+ serialized_engine: bytes, device=Device._current_device()
+) -> torch.jit.ScriptModule:
+ """Takes a pre-built serialized TensorRT engine and embeds it within a TorchScript module
+
+ Takes a pre-built serialied TensorRT engine (as bytes) and embeds it within a TorchScript module.
+ Registers the forward method to execute the TensorRT engine with the function signature:
+
+ forward(Tensor[]) -> Tensor[]
+
+ TensorRT bindings must have names with the following format:
+ - [symbol].[index in input / output array]
+ ex.
+ - [x.0, x.1, x.2] -> [y.0]
+
+ Module can be save with engine embedded with torch.jit.save and moved / loaded according to torch_tensorrt portability rules
+
+ Arguments:
+ serialized_engine (bytes): Serialized TensorRT engine from either torch_tensorrt or TensorRT APIs
+
+ Keyword Arguments:
+ device (Union(torch_tensorrt.Device, torch.device, dict)): Target device to run engine on. Must be compatible with engine provided. Default: Current active device
+
+ Returns:
+ torch.jit.ScriptModule: New TorchScript module with engine embedded
+ """
+ cpp_mod = _C.embed_engine_in_new_module(serialized_engine, _parse_device(device))
+ return torch.jit._recursive.wrap_cpp_module(cpp_mod)
+
+
+[docs]def check_method_op_support(module: torch.jit.ScriptModule, method_name: str) -> bool:
+ """Checks to see if a method is fully supported by torch_tensorrt
+
+ Checks if a method of a TorchScript module can be compiled by torch_tensorrt, if not, a list of operators
+ that are not supported are printed out and the function returns false, else true.
+
+ Arguments:
+ module (torch.jit.ScriptModule): Source module, a result of tracing or scripting a PyTorch
+ ``torch.nn.Module``
+ method_name (str): Name of method to check
+
+ Returns:
+ bool: True if supported Method
+ """
+ return _C.check_method_op_support(module._c, method_name)
+To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.
+
+ [1]:
+
+
+# Copyright 2019 NVIDIA Corporation. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+ 
+
+ + Citrinet + + is an acoustic model used for the speech to text recognition task. It is a version of + + QuartzNet + + that extends + + ContextNet + + , utilizing subword encoding (via Word Piece tokenization) and Squeeze-and-Excitation(SE) mechanism and are therefore smaller than QuartzNet models. +
++ CitriNet models take in audio segments and transcribe them to letter, byte pair, or word piece sequences. +
+
+ 
+
+ This notebook demonstrates the steps for optimizing a pretrained CitriNet model with Torch-TensorRT, and running it to test the speedup obtained. +
++ + Requirements + +
++ + Conclusion + +
++ ## 1. Requirements +
+
+ Follow the steps in
+
+ README
+
+ to prepare a Docker container, within which you can run this notebook. This notebook assumes that you are within a Jupyter environment in a docker container with Torch-TensorRT installed, such as an NGC monthly release of
+
+
+ nvcr.io/nvidia/pytorch:<yy.mm>-py3
+
+
+ (where
+
+
+ yy
+
+
+ indicates the last two numbers of a calendar year, and
+
+
+ mm
+
+
+ indicates the month in two-digit numerical form)
+
+ Now that you are in the docker, the next step is to install the required dependencies. +
+[2]:
+
+
+# Install dependencies
+!pip install wget
+!apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y libsndfile1 ffmpeg
+!pip install Cython
+
+## Install NeMo
+!pip install nemo_toolkit[all]==1.5.1
+
+
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Requirement already satisfied: wget in /opt/conda/lib/python3.8/site-packages (3.2)
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+Hit:1 http://security.ubuntu.com/ubuntu focal-security InRelease
+Hit:2 http://archive.ubuntu.com/ubuntu focal InRelease
+Hit:3 http://archive.ubuntu.com/ubuntu focal-updates InRelease
+Hit:4 http://archive.ubuntu.com/ubuntu focal-backports InRelease
+Reading package lists... Done
+Reading package lists... Done
+Building dependency tree
+Reading state information... Done
+libsndfile1 is already the newest version (1.0.28-7ubuntu0.1).
+ffmpeg is already the newest version (7:4.2.4-1ubuntu0.1).
+0 upgraded, 0 newly installed, 0 to remove and 22 not upgraded.
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Requirement already satisfied: Cython in /opt/conda/lib/python3.8/site-packages (0.29.28)
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Requirement already satisfied: nemo_toolkit[all]==1.5.1 in /opt/conda/lib/python3.8/site-packages (1.5.1)
+Requirement already satisfied: numpy>=1.18.2 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.22.3)
+Requirement already satisfied: onnx>=1.7.0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.10.1)
+Requirement already satisfied: python-dateutil in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.8.2)
+Requirement already satisfied: tqdm>=4.41.0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (4.63.0)
+Requirement already satisfied: sentencepiece<1.0.0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.1.96)
+Requirement already satisfied: wget in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (3.2)
+Requirement already satisfied: numba in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.53.1)
+Requirement already satisfied: torch in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.12.0a0+2c916ef)
+Requirement already satisfied: unidecode in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.3.4)
+Requirement already satisfied: frozendict in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.3.2)
+Requirement already satisfied: wrapt in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.14.0)
+Requirement already satisfied: scikit-learn in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.24.2)
+Requirement already satisfied: ruamel.yaml in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.17.21)
+Requirement already satisfied: pesq in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.0.3)
+Requirement already satisfied: torchvision in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.13.0a0)
+Requirement already satisfied: gdown in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (4.4.0)
+Requirement already satisfied: editdistance in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.6.0)
+Requirement already satisfied: boto3 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.21.45)
+Requirement already satisfied: isort[requirements]<5 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (4.3.21)
+Requirement already satisfied: hydra-core>=1.1.0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.1.2)
+Requirement already satisfied: youtokentome>=1.0.5 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.0.6)
+Requirement already satisfied: pytorch-lightning>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.6.1)
+Requirement already satisfied: jieba in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.42.1)
+Requirement already satisfied: fasttext in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.9.2)
+Requirement already satisfied: soundfile in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.10.3.post1)
+Requirement already satisfied: kaldiio in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.17.2)
+Requirement already satisfied: pangu in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (4.0.6.1)
+Requirement already satisfied: kaldi-python-io in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.2.2)
+Requirement already satisfied: parameterized in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.8.1)
+Requirement already satisfied: h5py in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (3.6.0)
+Requirement already satisfied: rapidfuzz in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.0.10)
+Requirement already satisfied: marshmallow in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (3.15.0)
+Requirement already satisfied: opencc in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.1.3)
+Requirement already satisfied: braceexpand in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.1.7)
+Requirement already satisfied: omegaconf>=2.1.0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.1.2)
+Requirement already satisfied: sphinx in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (4.4.0)
+Requirement already satisfied: pillow in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (9.0.0)
+Requirement already satisfied: wordninja==2.0.0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.0.0)
+Requirement already satisfied: torch-stft in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.1.4)
+Requirement already satisfied: sox in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.4.1)
+Requirement already satisfied: librosa in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.9.1)
+Requirement already satisfied: regex in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2022.3.15)
+Requirement already satisfied: sacrebleu[ja] in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.0.0)
+Requirement already satisfied: black==19.10b0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (19.10b0)
+Requirement already satisfied: pydub in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.25.1)
+Requirement already satisfied: sphinxcontrib-bibtex in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.4.2)
+Requirement already satisfied: inflect in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (5.5.2)
+Requirement already satisfied: pyannote.core in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (4.4)
+Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (21.3)
+Requirement already satisfied: kaldi-io in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.9.4)
+Requirement already satisfied: pyannote.metrics in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (3.2)
+Requirement already satisfied: g2p-en in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.1.0)
+Requirement already satisfied: matplotlib in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (3.5.1)
+Requirement already satisfied: torchmetrics>=0.4.1rc0 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.8.0)
+Requirement already satisfied: nltk>=3.6.5 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (3.7)
+Requirement already satisfied: pyyaml<6 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (5.4.1)
+Requirement already satisfied: scipy in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.6.3)
+Requirement already satisfied: ipywidgets in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (7.7.0)
+Requirement already satisfied: pytest in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (6.2.5)
+Requirement already satisfied: pandas in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (1.3.5)
+Requirement already satisfied: pytest-runner in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (6.0.0)
+Requirement already satisfied: transformers>=4.0.1 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (4.18.0)
+Requirement already satisfied: sacremoses>=0.0.43 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.0.49)
+Requirement already satisfied: pystoi in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.3.3)
+Requirement already satisfied: attrdict in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (2.0.1)
+Requirement already satisfied: webdataset<=0.1.62,>=0.1.48 in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.1.62)
+Requirement already satisfied: wandb in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.12.15)
+Requirement already satisfied: pypinyin in /opt/conda/lib/python3.8/site-packages (from nemo_toolkit[all]==1.5.1) (0.46.0)
+Requirement already satisfied: attrs>=18.1.0 in /opt/conda/lib/python3.8/site-packages (from black==19.10b0->nemo_toolkit[all]==1.5.1) (21.4.0)
+Requirement already satisfied: appdirs in /opt/conda/lib/python3.8/site-packages (from black==19.10b0->nemo_toolkit[all]==1.5.1) (1.4.4)
+Requirement already satisfied: typed-ast>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from black==19.10b0->nemo_toolkit[all]==1.5.1) (1.5.3)
+Requirement already satisfied: pathspec<1,>=0.6 in /opt/conda/lib/python3.8/site-packages (from black==19.10b0->nemo_toolkit[all]==1.5.1) (0.9.0)
+Requirement already satisfied: click>=6.5 in /opt/conda/lib/python3.8/site-packages (from black==19.10b0->nemo_toolkit[all]==1.5.1) (8.0.4)
+Requirement already satisfied: toml>=0.9.4 in /opt/conda/lib/python3.8/site-packages (from black==19.10b0->nemo_toolkit[all]==1.5.1) (0.10.2)
+Requirement already satisfied: antlr4-python3-runtime==4.8 in /opt/conda/lib/python3.8/site-packages (from hydra-core>=1.1.0->nemo_toolkit[all]==1.5.1) (4.8)
+Requirement already satisfied: importlib-resources<5.3 in /opt/conda/lib/python3.8/site-packages (from hydra-core>=1.1.0->nemo_toolkit[all]==1.5.1) (5.2.3)
+Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources<5.3->hydra-core>=1.1.0->nemo_toolkit[all]==1.5.1) (3.7.0)
+Requirement already satisfied: pip-api in /opt/conda/lib/python3.8/site-packages (from isort[requirements]<5->nemo_toolkit[all]==1.5.1) (0.0.29)
+Requirement already satisfied: pipreqs in /opt/conda/lib/python3.8/site-packages (from isort[requirements]<5->nemo_toolkit[all]==1.5.1) (0.4.11)
+Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.8/site-packages (from matplotlib->nemo_toolkit[all]==1.5.1) (4.31.2)
+Requirement already satisfied: kiwisolver>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from matplotlib->nemo_toolkit[all]==1.5.1) (1.4.0)
+Requirement already satisfied: pyparsing>=2.2.1 in /opt/conda/lib/python3.8/site-packages (from matplotlib->nemo_toolkit[all]==1.5.1) (3.0.7)
+Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.8/site-packages (from matplotlib->nemo_toolkit[all]==1.5.1) (0.11.0)
+Requirement already satisfied: joblib in /opt/conda/lib/python3.8/site-packages (from nltk>=3.6.5->nemo_toolkit[all]==1.5.1) (1.1.0)
+Requirement already satisfied: typing-extensions>=3.6.2.1 in /opt/conda/lib/python3.8/site-packages (from onnx>=1.7.0->nemo_toolkit[all]==1.5.1) (4.1.1)
+Requirement already satisfied: six in /opt/conda/lib/python3.8/site-packages (from onnx>=1.7.0->nemo_toolkit[all]==1.5.1) (1.16.0)
+Requirement already satisfied: protobuf>=3.12.2 in /opt/conda/lib/python3.8/site-packages (from onnx>=1.7.0->nemo_toolkit[all]==1.5.1) (3.19.4)
+Requirement already satisfied: pyDeprecate<0.4.0,>=0.3.1 in /opt/conda/lib/python3.8/site-packages (from pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (0.3.2)
+Requirement already satisfied: tensorboard>=2.2.0 in /opt/conda/lib/python3.8/site-packages (from pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (2.8.0)
+Requirement already satisfied: fsspec[http]!=2021.06.0,>=2021.05.0 in /opt/conda/lib/python3.8/site-packages (from pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (2022.2.0)
+Requirement already satisfied: requests in /opt/conda/lib/python3.8/site-packages (from fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (2.27.1)
+Requirement already satisfied: aiohttp in /opt/conda/lib/python3.8/site-packages (from fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (3.8.1)
+Requirement already satisfied: werkzeug>=0.11.15 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (2.0.3)
+Requirement already satisfied: markdown>=2.6.8 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (3.3.6)
+Requirement already satisfied: setuptools>=41.0.0 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (59.5.0)
+Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (0.4.6)
+Requirement already satisfied: google-auth<3,>=1.6.3 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (2.6.2)
+Requirement already satisfied: wheel>=0.26 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (0.37.1)
+Requirement already satisfied: grpcio>=1.24.3 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.44.0)
+Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (0.6.1)
+Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.8.1)
+Requirement already satisfied: absl-py>=0.4 in /opt/conda/lib/python3.8/site-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.0.0)
+Requirement already satisfied: cachetools<6.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (5.0.0)
+Requirement already satisfied: pyasn1-modules>=0.2.1 in /opt/conda/lib/python3.8/site-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (0.2.8)
+Requirement already satisfied: rsa<5,>=3.1.4 in /opt/conda/lib/python3.8/site-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (4.8)
+Requirement already satisfied: requests-oauthlib>=0.7.0 in /opt/conda/lib/python3.8/site-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.3.1)
+Requirement already satisfied: importlib-metadata>=4.4 in /opt/conda/lib/python3.8/site-packages (from markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (4.11.3)
+Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /opt/conda/lib/python3.8/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (0.4.8)
+Requirement already satisfied: charset-normalizer~=2.0.0 in /opt/conda/lib/python3.8/site-packages (from requests->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (2.0.12)
+Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.8/site-packages (from requests->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (2021.10.8)
+Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.8/site-packages (from requests->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (3.3)
+Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.8/site-packages (from requests->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.26.8)
+Requirement already satisfied: oauthlib>=3.0.0 in /opt/conda/lib/python3.8/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (3.2.0)
+Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from transformers>=4.0.1->nemo_toolkit[all]==1.5.1) (0.5.1)
+Requirement already satisfied: tokenizers!=0.11.3,<0.13,>=0.11.1 in /opt/conda/lib/python3.8/site-packages (from transformers>=4.0.1->nemo_toolkit[all]==1.5.1) (0.12.1)
+Requirement already satisfied: filelock in /opt/conda/lib/python3.8/site-packages (from transformers>=4.0.1->nemo_toolkit[all]==1.5.1) (3.6.0)
+Requirement already satisfied: frozenlist>=1.1.1 in /opt/conda/lib/python3.8/site-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.3.0)
+Requirement already satisfied: yarl<2.0,>=1.0 in /opt/conda/lib/python3.8/site-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.7.2)
+Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /opt/conda/lib/python3.8/site-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (4.0.2)
+Requirement already satisfied: multidict<7.0,>=4.5 in /opt/conda/lib/python3.8/site-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (6.0.2)
+Requirement already satisfied: aiosignal>=1.1.2 in /opt/conda/lib/python3.8/site-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.2.0)
+Requirement already satisfied: s3transfer<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from boto3->nemo_toolkit[all]==1.5.1) (0.5.2)
+Requirement already satisfied: botocore<1.25.0,>=1.24.45 in /opt/conda/lib/python3.8/site-packages (from boto3->nemo_toolkit[all]==1.5.1) (1.24.45)
+Requirement already satisfied: jmespath<2.0.0,>=0.7.1 in /opt/conda/lib/python3.8/site-packages (from boto3->nemo_toolkit[all]==1.5.1) (1.0.0)
+Requirement already satisfied: pybind11>=2.2 in /opt/conda/lib/python3.8/site-packages (from fasttext->nemo_toolkit[all]==1.5.1) (2.9.1)
+Requirement already satisfied: distance>=0.1.3 in /opt/conda/lib/python3.8/site-packages (from g2p-en->nemo_toolkit[all]==1.5.1) (0.1.3)
+Requirement already satisfied: beautifulsoup4 in /opt/conda/lib/python3.8/site-packages (from gdown->nemo_toolkit[all]==1.5.1) (4.10.0)
+Requirement already satisfied: soupsieve>1.2 in /opt/conda/lib/python3.8/site-packages (from beautifulsoup4->gdown->nemo_toolkit[all]==1.5.1) (2.3.1)
+Requirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets->nemo_toolkit[all]==1.5.1) (0.2.0)
+Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets->nemo_toolkit[all]==1.5.1) (8.1.1)
+Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets->nemo_toolkit[all]==1.5.1) (6.9.2)
+Requirement already satisfied: jupyterlab-widgets>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets->nemo_toolkit[all]==1.5.1) (1.1.0)
+Requirement already satisfied: widgetsnbextension~=3.6.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets->nemo_toolkit[all]==1.5.1) (3.6.0)
+Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets->nemo_toolkit[all]==1.5.1) (5.1.1)
+Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets->nemo_toolkit[all]==1.5.1) (5.2.0)
+Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (7.1.2)
+Requirement already satisfied: psutil in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (5.9.0)
+Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (6.1)
+Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (1.5.1)
+Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (1.5.4)
+Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (0.1.3)
+Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.7.5)
+Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (5.1.1)
+Requirement already satisfied: pygments>=2.4.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (2.11.2)
+Requirement already satisfied: stack-data in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.2.0)
+Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (3.0.27)
+Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.2.0)
+Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.18.1)
+Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (4.8.0)
+Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.8.3)
+Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (0.4)
+Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (22.3.0)
+Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets->nemo_toolkit[all]==1.5.1) (4.9.2)
+Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets->nemo_toolkit[all]==1.5.1) (4.4.0)
+Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.18.1)
+Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.7.0)
+Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.2.5)
+Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (6.4.1)
+Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (1.8.0)
+Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.13.1)
+Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.13.3)
+Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (3.0.3)
+Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (6.4.4)
+Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (21.3.0)
+Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (21.2.0)
+Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (1.15.0)
+Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (2.21)
+Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (2.1.1)
+Requirement already satisfied: resampy>=0.2.2 in /opt/conda/lib/python3.8/site-packages (from librosa->nemo_toolkit[all]==1.5.1) (0.2.2)
+Requirement already satisfied: pooch>=1.0 in /opt/conda/lib/python3.8/site-packages (from librosa->nemo_toolkit[all]==1.5.1) (1.6.0)
+Requirement already satisfied: audioread>=2.1.5 in /opt/conda/lib/python3.8/site-packages (from librosa->nemo_toolkit[all]==1.5.1) (2.1.9)
+Requirement already satisfied: llvmlite<0.37,>=0.36.0rc1 in /opt/conda/lib/python3.8/site-packages (from numba->nemo_toolkit[all]==1.5.1) (0.36.0)
+Requirement already satisfied: threadpoolctl>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from scikit-learn->nemo_toolkit[all]==1.5.1) (3.1.0)
+Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.7.1)
+Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.5.13)
+Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (4.1.0)
+Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.8.4)
+Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (1.5.0)
+Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.6.0)
+Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.1.2)
+Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.5.1)
+Requirement already satisfied: pytz>=2017.3 in /opt/conda/lib/python3.8/site-packages (from pandas->nemo_toolkit[all]==1.5.1) (2021.3)
+Requirement already satisfied: pip in /opt/conda/lib/python3.8/site-packages (from pip-api->isort[requirements]<5->nemo_toolkit[all]==1.5.1) (21.2.4)
+Requirement already satisfied: yarg in /opt/conda/lib/python3.8/site-packages (from pipreqs->isort[requirements]<5->nemo_toolkit[all]==1.5.1) (0.1.9)
+Requirement already satisfied: docopt in /opt/conda/lib/python3.8/site-packages (from pipreqs->isort[requirements]<5->nemo_toolkit[all]==1.5.1) (0.6.2)
+Requirement already satisfied: simplejson>=3.8.1 in /opt/conda/lib/python3.8/site-packages (from pyannote.core->nemo_toolkit[all]==1.5.1) (3.17.6)
+Requirement already satisfied: sortedcontainers>=2.0.4 in /opt/conda/lib/python3.8/site-packages (from pyannote.core->nemo_toolkit[all]==1.5.1) (2.4.0)
+Requirement already satisfied: tabulate>=0.7.7 in /opt/conda/lib/python3.8/site-packages (from pyannote.metrics->nemo_toolkit[all]==1.5.1) (0.8.9)
+Requirement already satisfied: pyannote.database>=4.0.1 in /opt/conda/lib/python3.8/site-packages (from pyannote.metrics->nemo_toolkit[all]==1.5.1) (4.1.3)
+Requirement already satisfied: sympy>=1.1 in /opt/conda/lib/python3.8/site-packages (from pyannote.metrics->nemo_toolkit[all]==1.5.1) (1.10.1)
+Requirement already satisfied: typer[all]>=0.2.1 in /opt/conda/lib/python3.8/site-packages (from pyannote.database>=4.0.1->pyannote.metrics->nemo_toolkit[all]==1.5.1) (0.4.0)
+Requirement already satisfied: mpmath>=0.19 in /opt/conda/lib/python3.8/site-packages (from sympy>=1.1->pyannote.metrics->nemo_toolkit[all]==1.5.1) (1.2.1)
+Requirement already satisfied: colorama<0.5.0,>=0.4.3 in /opt/conda/lib/python3.8/site-packages (from typer[all]>=0.2.1->pyannote.database>=4.0.1->pyannote.metrics->nemo_toolkit[all]==1.5.1) (0.4.4)
+Requirement already satisfied: shellingham<2.0.0,>=1.3.0 in /opt/conda/lib/python3.8/site-packages (from typer[all]>=0.2.1->pyannote.database>=4.0.1->pyannote.metrics->nemo_toolkit[all]==1.5.1) (1.4.0)
+Requirement already satisfied: py>=1.8.2 in /opt/conda/lib/python3.8/site-packages (from pytest->nemo_toolkit[all]==1.5.1) (1.11.0)
+Requirement already satisfied: iniconfig in /opt/conda/lib/python3.8/site-packages (from pytest->nemo_toolkit[all]==1.5.1) (1.1.1)
+Requirement already satisfied: pluggy<2.0,>=0.12 in /opt/conda/lib/python3.8/site-packages (from pytest->nemo_toolkit[all]==1.5.1) (1.0.0)
+Requirement already satisfied: jarowinkler<1.1.0,>=1.0.2 in /opt/conda/lib/python3.8/site-packages (from rapidfuzz->nemo_toolkit[all]==1.5.1) (1.0.2)
+Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in /opt/conda/lib/python3.8/site-packages (from requests->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.5.0->nemo_toolkit[all]==1.5.1) (1.7.1)
+Requirement already satisfied: ruamel.yaml.clib>=0.2.6 in /opt/conda/lib/python3.8/site-packages (from ruamel.yaml->nemo_toolkit[all]==1.5.1) (0.2.6)
+Requirement already satisfied: portalocker in /opt/conda/lib/python3.8/site-packages (from sacrebleu[ja]->nemo_toolkit[all]==1.5.1) (2.4.0)
+Requirement already satisfied: ipadic<2.0,>=1.0 in /opt/conda/lib/python3.8/site-packages (from sacrebleu[ja]->nemo_toolkit[all]==1.5.1) (1.0.0)
+Requirement already satisfied: mecab-python3==1.0.3 in /opt/conda/lib/python3.8/site-packages (from sacrebleu[ja]->nemo_toolkit[all]==1.5.1) (1.0.3)
+Requirement already satisfied: sphinxcontrib-htmlhelp>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (2.0.0)
+Requirement already satisfied: alabaster<0.8,>=0.7 in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (0.7.12)
+Requirement already satisfied: babel>=1.3 in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (2.9.1)
+Requirement already satisfied: sphinxcontrib-serializinghtml>=1.1.5 in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (1.1.5)
+Requirement already satisfied: sphinxcontrib-devhelp in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (1.0.2)
+Requirement already satisfied: sphinxcontrib-jsmath in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (1.0.1)
+Requirement already satisfied: sphinxcontrib-qthelp in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (1.0.3)
+Requirement already satisfied: snowballstemmer>=1.1 in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (2.2.0)
+Requirement already satisfied: imagesize in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (1.3.0)
+Requirement already satisfied: sphinxcontrib-applehelp in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (1.0.2)
+Requirement already satisfied: docutils<0.18,>=0.14 in /opt/conda/lib/python3.8/site-packages (from sphinx->nemo_toolkit[all]==1.5.1) (0.17.1)
+Requirement already satisfied: pybtex-docutils>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from sphinxcontrib-bibtex->nemo_toolkit[all]==1.5.1) (1.0.1)
+Requirement already satisfied: pybtex>=0.24 in /opt/conda/lib/python3.8/site-packages (from sphinxcontrib-bibtex->nemo_toolkit[all]==1.5.1) (0.24.0)
+Requirement already satisfied: latexcodec>=1.0.4 in /opt/conda/lib/python3.8/site-packages (from pybtex>=0.24->sphinxcontrib-bibtex->nemo_toolkit[all]==1.5.1) (2.0.1)
+Requirement already satisfied: pure-eval in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.2.2)
+Requirement already satisfied: asttokens in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (2.0.5)
+Requirement already satisfied: executing in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets->nemo_toolkit[all]==1.5.1) (0.8.3)
+Requirement already satisfied: pathtools in /opt/conda/lib/python3.8/site-packages (from wandb->nemo_toolkit[all]==1.5.1) (0.1.2)
+Requirement already satisfied: setproctitle in /opt/conda/lib/python3.8/site-packages (from wandb->nemo_toolkit[all]==1.5.1) (1.2.3)
+Requirement already satisfied: GitPython>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from wandb->nemo_toolkit[all]==1.5.1) (3.1.27)
+Requirement already satisfied: sentry-sdk>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from wandb->nemo_toolkit[all]==1.5.1) (1.5.10)
+Requirement already satisfied: shortuuid>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from wandb->nemo_toolkit[all]==1.5.1) (1.0.8)
+Requirement already satisfied: docker-pycreds>=0.4.0 in /opt/conda/lib/python3.8/site-packages (from wandb->nemo_toolkit[all]==1.5.1) (0.4.0)
+Requirement already satisfied: promise<3,>=2.0 in /opt/conda/lib/python3.8/site-packages (from wandb->nemo_toolkit[all]==1.5.1) (2.3)
+Requirement already satisfied: gitdb<5,>=4.0.1 in /opt/conda/lib/python3.8/site-packages (from GitPython>=1.0.0->wandb->nemo_toolkit[all]==1.5.1) (4.0.9)
+Requirement already satisfied: smmap<6,>=3.0.1 in /opt/conda/lib/python3.8/site-packages (from gitdb<5,>=4.0.1->GitPython>=1.0.0->wandb->nemo_toolkit[all]==1.5.1) (5.0.0)
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+
+ + ## 2. Download Citrinet model +
++ Next, we download a pretrained Nemo Citrinet model and convert it to a Torchscript module: +
+[3]:
+
+
+import nemo
+import torch
+
+import nemo.collections.asr as nemo_asr
+from nemo.core import typecheck
+typecheck.set_typecheck_enabled(False)
+
+ [4]:
+
+
+variant = 'stt_en_citrinet_256'
+
+print(f"Downloading and saving {variant}...")
+asr_model = nemo_asr.models.EncDecCTCModelBPE.from_pretrained(model_name=variant)
+asr_model.export(f"{variant}.ts")
+
+
+Downloading and saving stt_en_citrinet_256...
+[NeMo I 2022-04-21 23:12:45 cloud:56] Found existing object /root/.cache/torch/NeMo/NeMo_1.5.1/stt_en_citrinet_256/91a9cc5850784b2065e8a0aa3d526fd9/stt_en_citrinet_256.nemo.
+[NeMo I 2022-04-21 23:12:45 cloud:62] Re-using file from: /root/.cache/torch/NeMo/NeMo_1.5.1/stt_en_citrinet_256/91a9cc5850784b2065e8a0aa3d526fd9/stt_en_citrinet_256.nemo
+[NeMo I 2022-04-21 23:12:45 common:728] Instantiating model from pre-trained checkpoint
+[NeMo I 2022-04-21 23:12:46 mixins:146] Tokenizer SentencePieceTokenizer initialized with 1024 tokens
+
+
+[NeMo W 2022-04-21 23:12:47 modelPT:130] If you intend to do training or fine-tuning, please call the ModelPT.setup_training_data() method and provide a valid configuration file to setup the train data loader.
+ Train config :
+ manifest_filepath: null
+ sample_rate: 16000
+ batch_size: 32
+ trim_silence: true
+ max_duration: 16.7
+ shuffle: true
+ is_tarred: false
+ tarred_audio_filepaths: null
+ use_start_end_token: false
+
+[NeMo W 2022-04-21 23:12:47 modelPT:137] If you intend to do validation, please call the ModelPT.setup_validation_data() or ModelPT.setup_multiple_validation_data() method and provide a valid configuration file to setup the validation data loader(s).
+ Validation config :
+ manifest_filepath: null
+ sample_rate: 16000
+ batch_size: 32
+ shuffle: false
+ use_start_end_token: false
+
+[NeMo W 2022-04-21 23:12:47 modelPT:143] Please call the ModelPT.setup_test_data() or ModelPT.setup_multiple_test_data() method and provide a valid configuration file to setup the test data loader(s).
+ Test config :
+ manifest_filepath: null
+ sample_rate: 16000
+ batch_size: 32
+ shuffle: false
+ use_start_end_token: false
+
+
+
+[NeMo I 2022-04-21 23:12:47 features:265] PADDING: 16
+[NeMo I 2022-04-21 23:12:47 features:282] STFT using torch
+
+
+[NeMo W 2022-04-21 23:12:47 nemo_logging:349] /opt/conda/lib/python3.8/site-packages/nemo/collections/asr/parts/preprocessing/features.py:315: FutureWarning: Pass sr=16000, n_fft=512 as keyword args. From version 0.10 passing these as positional arguments will result in an error
+ librosa.filters.mel(sample_rate, self.n_fft, n_mels=nfilt, fmin=lowfreq, fmax=highfreq), dtype=torch.float
+
+
+
+[NeMo I 2022-04-21 23:12:49 save_restore_connector:149] Model EncDecCTCModelBPE was successfully restored from /root/.cache/torch/NeMo/NeMo_1.5.1/stt_en_citrinet_256/91a9cc5850784b2065e8a0aa3d526fd9/stt_en_citrinet_256.nemo.
+
+
+[NeMo W 2022-04-21 23:12:49 export_utils:198] Swapped 0 modules
+[NeMo W 2022-04-21 23:12:49 conv_asr:73] Turned off 235 masked convolutions
+[NeMo W 2022-04-21 23:12:49 export_utils:198] Swapped 0 modules
+[NeMo W 2022-04-21 23:12:50 nemo_logging:349] /opt/conda/lib/python3.8/site-packages/torch/jit/_trace.py:916: UserWarning: `optimize` is deprecated and has no effect. Use `with torch.jit.optimized_execution() instead
+ warnings.warn(
+
+[NeMo W 2022-04-21 23:12:50 nemo_logging:349] /opt/conda/lib/python3.8/site-packages/torch/_jit_internal.py:668: LightningDeprecationWarning: The `LightningModule.model_size` property was deprecated in v1.5 and will be removed in v1.7. Please use the `pytorch_lightning.utilities.memory.get_model_size_mb`.
+ if hasattr(mod, name):
+
+[NeMo W 2022-04-21 23:12:50 nemo_logging:349] /opt/conda/lib/python3.8/site-packages/torch/_jit_internal.py:669: LightningDeprecationWarning: The `LightningModule.model_size` property was deprecated in v1.5 and will be removed in v1.7. Please use the `pytorch_lightning.utilities.memory.get_model_size_mb`.
+ item = getattr(mod, name)
+
+[NeMo W 2022-04-21 23:12:50 nemo_logging:349] /opt/conda/lib/python3.8/site-packages/torch/_jit_internal.py:668: LightningDeprecationWarning: `LightningModule.use_amp` was deprecated in v1.6 and will be removed in v1.8. Please use `Trainer.amp_backend`.
+ if hasattr(mod, name):
+
+[NeMo W 2022-04-21 23:12:50 nemo_logging:349] /opt/conda/lib/python3.8/site-packages/torch/_jit_internal.py:669: LightningDeprecationWarning: `LightningModule.use_amp` was deprecated in v1.6 and will be removed in v1.8. Please use `Trainer.amp_backend`.
+ item = getattr(mod, name)
+
+
+ [4]:
+
+
+(['stt_en_citrinet_256.ts'],
+ ['nemo.collections.asr.models.ctc_bpe_models.EncDecCTCModelBPE exported to ONNX'])
+
+ + Let us define a helper benchmarking function, then benchmark the original Pytorch model. +
+[5]:
+
+
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
+import argparse
+import timeit
+import numpy as np
+import torch
+import torch_tensorrt as trtorch
+import torch.backends.cudnn as cudnn
+
+def benchmark(model, input_tensor, num_loops, model_name, batch_size):
+ def timeGraph(model, input_tensor, num_loops):
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(20):
+ features = model(input_tensor)
+
+ torch.cuda.synchronize()
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(num_loops):
+ start_time = timeit.default_timer()
+ features = model(input_tensor)
+ torch.cuda.synchronize()
+ end_time = timeit.default_timer()
+ timings.append(end_time - start_time)
+ # print("Iteration {}: {:.6f} s".format(i, end_time - start_time))
+ return timings
+ def printStats(graphName, timings, batch_size):
+ times = np.array(timings)
+ steps = len(times)
+ speeds = batch_size / times
+ time_mean = np.mean(times)
+ time_med = np.median(times)
+ time_99th = np.percentile(times, 99)
+ time_std = np.std(times, ddof=0)
+ speed_mean = np.mean(speeds)
+ speed_med = np.median(speeds)
+ msg = ("\n%s =================================\n"
+ "batch size=%d, num iterations=%d\n"
+ " Median samples/s: %.1f, mean: %.1f\n"
+ " Median latency (s): %.6f, mean: %.6f, 99th_p: %.6f, std_dev: %.6f\n"
+ ) % (graphName,
+ batch_size, steps,
+ speed_med, speed_mean,
+ time_med, time_mean, time_99th, time_std)
+ print(msg)
+ timings = timeGraph(model, input_tensor, num_loops)
+ printStats(model_name, timings, batch_size)
+
+precisions_str = 'fp32' # Precision (default=fp32, fp16)
+variant = 'stt_en_citrinet_256' # Nemo Citrinet variant
+batch_sizes = [1, 8, 32, 128] # Batch sizes (default=1,8,32,128)
+trt = False # If True, infer with Torch-TensorRT engine. Else, infer with Pytorch model.
+precision = torch.float32 if precisions_str =='fp32' else torch.float16
+
+for batch_size in batch_sizes:
+ if trt:
+ model_name = f"{variant}_bs{batch_size}_{precision}.torch-tensorrt"
+ else:
+ model_name = f"{variant}.ts"
+
+ print(f"Loading model: {model_name}")
+ # Load traced model to CPU first
+ model = torch.jit.load(model_name).cuda()
+ cudnn.benchmark = True
+ # Create random input tensor of certain size
+ torch.manual_seed(12345)
+ input_shape=(batch_size, 80, 1488)
+ input_tensor = torch.randn(input_shape).cuda()
+
+ # Timing graph inference
+ benchmark(model, input_tensor, 50, model_name, batch_size)
+
+
+Loading model: stt_en_citrinet_256.ts
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256.ts =================================
+batch size=1, num iterations=50
+ Median samples/s: 102.0, mean: 102.0
+ Median latency (s): 0.009802, mean: 0.009803, 99th_p: 0.009836, std_dev: 0.000014
+
+Loading model: stt_en_citrinet_256.ts
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256.ts =================================
+batch size=8, num iterations=50
+ Median samples/s: 429.1, mean: 429.1
+ Median latency (s): 0.018642, mean: 0.018643, 99th_p: 0.018670, std_dev: 0.000014
+
+Loading model: stt_en_citrinet_256.ts
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256.ts =================================
+batch size=32, num iterations=50
+ Median samples/s: 551.3, mean: 551.2
+ Median latency (s): 0.058047, mean: 0.058053, 99th_p: 0.058375, std_dev: 0.000106
+
+Loading model: stt_en_citrinet_256.ts
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256.ts =================================
+batch size=128, num iterations=50
+ Median samples/s: 594.1, mean: 594.1
+ Median latency (s): 0.215434, mean: 0.215446, 99th_p: 0.215806, std_dev: 0.000116
+
+
+ + Confirming the GPU we are using here: +
+[6]:
+
+
+!nvidia-smi
+
+
+Thu Apr 21 23:13:32 2022
++-----------------------------------------------------------------------------+
+| NVIDIA-SMI 510.47.03 Driver Version: 510.47.03 CUDA Version: 11.6 |
+|-------------------------------+----------------------+----------------------+
+| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
+| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
+| | | MIG M. |
+|===============================+======================+======================|
+| 0 NVIDIA TITAN V On | 00000000:17:00.0 Off | N/A |
+| 38% 55C P2 42W / 250W | 2462MiB / 12288MiB | 0% Default |
+| | | N/A |
++-------------------------------+----------------------+----------------------+
+| 1 NVIDIA TITAN V On | 00000000:65:00.0 Off | N/A |
+| 28% 39C P8 26W / 250W | 112MiB / 12288MiB | 0% Default |
+| | | N/A |
++-------------------------------+----------------------+----------------------+
+
++-----------------------------------------------------------------------------+
+| Processes: |
+| GPU GI CI PID Type Process name GPU Memory |
+| ID ID Usage |
+|=============================================================================|
+| 0 N/A N/A 3909 G 4MiB |
+| 0 N/A N/A 6047 C 2453MiB |
+| 1 N/A N/A 3909 G 39MiB |
+| 1 N/A N/A 4161 G 67MiB |
++-----------------------------------------------------------------------------+
+
+ + ## 3. Create Torch-TensorRT modules +
++ In this step, we optimize the Citrinet Torchscript module with Torch-TensorRT with various precisions and batch sizes. +
+[10]:
+
+
+import torch
+import torch.nn as nn
+import torch_tensorrt as torchtrt
+import argparse
+
+variant = "stt_en_citrinet_256"
+precisions = [torch.float, torch.half]
+batch_sizes = [1,8,32,128]
+
+model = torch.jit.load(f"{variant}.ts")
+
+for precision in precisions:
+ for batch_size in batch_sizes:
+ compile_settings = {
+ "inputs": [torchtrt.Input(shape=[batch_size, 80, 1488])],
+ "enabled_precisions": {precision},
+ "workspace_size": 2000000000,
+ "truncate_long_and_double": True,
+ }
+ print(f"Generating Torchscript-TensorRT module for batchsize {batch_size} precision {precision}")
+ trt_ts_module = torchtrt.compile(model, **compile_settings)
+ torch.jit.save(trt_ts_module, f"{variant}_bs{batch_size}_{precision}.torch-tensorrt")
+
+
+Generating Torchscript-TensorRT module for batchsize 1 precision torch.float32
+Generating Torchscript-TensorRT module for batchsize 8 precision torch.float32
+Generating Torchscript-TensorRT module for batchsize 32 precision torch.float32
+Generating Torchscript-TensorRT module for batchsize 128 precision torch.float32
+Generating Torchscript-TensorRT module for batchsize 1 precision torch.float16
+Generating Torchscript-TensorRT module for batchsize 8 precision torch.float16
+Generating Torchscript-TensorRT module for batchsize 32 precision torch.float16
+Generating Torchscript-TensorRT module for batchsize 128 precision torch.float16
+
+ + ## 4. Benchmark Torch-TensorRT models +
++ Finally, we are ready to benchmark the Torch-TensorRT optimized Citrinet models. +
+[13]:
+
+
+precisions_str = 'fp32' # Precision (default=fp32, fp16)
+batch_sizes = [1, 8, 32, 128] # Batch sizes (default=1,8,32,128)
+precision = torch.float32 if precisions_str =='fp32' else torch.float16
+trt = True
+
+for batch_size in batch_sizes:
+ if trt:
+ model_name = f"{variant}_bs{batch_size}_{precision}.torch-tensorrt"
+ else:
+ model_name = f"{variant}.ts"
+
+ print(f"Loading model: {model_name}")
+ # Load traced model to CPU first
+ model = torch.jit.load(model_name).cuda()
+ cudnn.benchmark = True
+ # Create random input tensor of certain size
+ torch.manual_seed(12345)
+ input_shape=(batch_size, 80, 1488)
+ input_tensor = torch.randn(input_shape).cuda()
+
+ # Timing graph inference
+ benchmark(model, input_tensor, 50, model_name, batch_size)
+
+
+Loading model: stt_en_citrinet_256_bs1_torch.float32.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs1_torch.float32.torch-tensorrt =================================
+batch size=1, num iterations=50
+ Median samples/s: 242.2, mean: 218.0
+ Median latency (s): 0.004128, mean: 0.004825, 99th_p: 0.008071, std_dev: 0.001270
+
+Loading model: stt_en_citrinet_256_bs8_torch.float32.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs8_torch.float32.torch-tensorrt =================================
+batch size=8, num iterations=50
+ Median samples/s: 729.9, mean: 709.0
+ Median latency (s): 0.010961, mean: 0.011388, 99th_p: 0.016114, std_dev: 0.001256
+
+Loading model: stt_en_citrinet_256_bs32_torch.float32.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs32_torch.float32.torch-tensorrt =================================
+batch size=32, num iterations=50
+ Median samples/s: 955.6, mean: 953.4
+ Median latency (s): 0.033488, mean: 0.033572, 99th_p: 0.035722, std_dev: 0.000545
+
+Loading model: stt_en_citrinet_256_bs128_torch.float32.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs128_torch.float32.torch-tensorrt =================================
+batch size=128, num iterations=50
+ Median samples/s: 1065.8, mean: 1069.4
+ Median latency (s): 0.120097, mean: 0.119708, 99th_p: 0.121618, std_dev: 0.001260
+
+
+ [14]:
+
+
+precisions_str = 'fp16' # Precision (default=fp32, fp16)
+batch_sizes = [1, 8, 32, 128] # Batch sizes (default=1,8,32,128)
+precision = torch.float32 if precisions_str =='fp32' else torch.float16
+
+for batch_size in batch_sizes:
+ if trt:
+ model_name = f"{variant}_bs{batch_size}_{precision}.torch-tensorrt"
+ else:
+ model_name = f"{variant}.ts"
+
+ print(f"Loading model: {model_name}")
+ # Load traced model to CPU first
+ model = torch.jit.load(model_name).cuda()
+ cudnn.benchmark = True
+ # Create random input tensor of certain size
+ torch.manual_seed(12345)
+ input_shape=(batch_size, 80, 1488)
+ input_tensor = torch.randn(input_shape).cuda()
+
+ # Timing graph inference
+ benchmark(model, input_tensor, 50, model_name, batch_size)
+
+
+Loading model: stt_en_citrinet_256_bs1_torch.float16.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs1_torch.float16.torch-tensorrt =================================
+batch size=1, num iterations=50
+ Median samples/s: 288.9, mean: 272.9
+ Median latency (s): 0.003462, mean: 0.003774, 99th_p: 0.006846, std_dev: 0.000820
+
+Loading model: stt_en_citrinet_256_bs8_torch.float16.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs8_torch.float16.torch-tensorrt =================================
+batch size=8, num iterations=50
+ Median samples/s: 1201.0, mean: 1190.9
+ Median latency (s): 0.006661, mean: 0.006733, 99th_p: 0.008453, std_dev: 0.000368
+
+Loading model: stt_en_citrinet_256_bs32_torch.float16.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs32_torch.float16.torch-tensorrt =================================
+batch size=32, num iterations=50
+ Median samples/s: 1538.2, mean: 1516.4
+ Median latency (s): 0.020804, mean: 0.021143, 99th_p: 0.024492, std_dev: 0.000973
+
+Loading model: stt_en_citrinet_256_bs128_torch.float16.torch-tensorrt
+Warm up ...
+Start timing ...
+
+stt_en_citrinet_256_bs128_torch.float16.torch-tensorrt =================================
+batch size=128, num iterations=50
+ Median samples/s: 1792.0, mean: 1777.0
+ Median latency (s): 0.071428, mean: 0.072057, 99th_p: 0.076796, std_dev: 0.001351
+
+
+ + ## 5. Conclusion +
++ In this notebook, we have walked through the complete process of optimizing the Citrinet model with Torch-TensorRT. On an A100 GPU, with Torch-TensorRT, we observe a speedup of ~ + + 2.4X + + with FP32, and ~ + + 2.9X + + with FP16 at batchsize of 128. +
++ Now it’s time to try Torch-TensorRT on your own model. Fill out issues at + + https://github.com/NVIDIA/Torch-TensorRT + + . Your involvement will help future development of Torch-TensorRT. +
+[ ]:
+
+
+
+
+ ![](\"http://developer.download.nvidia.com/compute/machine-learning/frameworks/nvidia_logo.png\"){kind=logo}
\n",
+ "\n",
+ "# Torch-TensorRT Getting Started - CitriNet"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "[Citrinet](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/models.html#citrinet) is an acoustic model used for the speech to text recognition task. It is a version of [QuartzNet](https://arxiv.org/pdf/1910.10261.pdf) that extends [ContextNet](https://arxiv.org/pdf/2005.03191.pdf), utilizing subword encoding (via Word Piece tokenization) and Squeeze-and-Excitation(SE) mechanism and are therefore smaller than QuartzNet models.\n",
+ "\n",
+ "CitriNet models take in audio segments and transcribe them to letter, byte pair, or word piece sequences. \n",
+ "\n",
+ "![\"alt\"](\"https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/_images/jasper_vertical.png\")
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for optimizing a pretrained CitriNet model with Torch-TensorRT, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [Download Citrinet model](#2)\n",
+ "1. [Create Torch-TensorRT modules](#3)\n",
+ "1. [Benchmark Torch-TensorRT models](#4)\n",
+ "1. [Conclusion](#5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "Follow the steps in [README](README.md) to prepare a Docker container, within which you can run this notebook. \n",
+ "This notebook assumes that you are within a Jupyter environment in a docker container with Torch-TensorRT installed, such as an NGC monthly release of `nvcr.io/nvidia/pytorch:[1]:
+
+
+# Copyright 2019 NVIDIA Corporation. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+
+
+ In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the +best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch’s JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new +world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference. +
++ When deploying on NVIDIA GPUs TensorRT, NVIDIA’s Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA’s Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that +perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device. +
++ Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch. +
++ This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained EfficientNet network, and running it to test the speedup obtained. +
++ + Requirements + +
++ + Conclusion + +
+[1]:
+
+
+!pip install timm==0.4.12
+!nvidia-smi
+
+
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Collecting timm==0.4.12
+ Downloading timm-0.4.12-py3-none-any.whl (376 kB)
+ |████████████████████████████████| 376 kB 11.9 MB/s eta 0:00:01
+Requirement already satisfied: torch>=1.4 in /opt/conda/lib/python3.8/site-packages (from timm==0.4.12) (1.11.0a0+bfe5ad2)
+Requirement already satisfied: torchvision in /opt/conda/lib/python3.8/site-packages (from timm==0.4.12) (0.12.0a0)
+Requirement already satisfied: typing_extensions in /opt/conda/lib/python3.8/site-packages (from torch>=1.4->timm==0.4.12) (4.0.1)
+Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /opt/conda/lib/python3.8/site-packages (from torchvision->timm==0.4.12) (8.2.0)
+Requirement already satisfied: numpy in /opt/conda/lib/python3.8/site-packages (from torchvision->timm==0.4.12) (1.22.0)
+Installing collected packages: timm
+Successfully installed timm-0.4.12
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+Fri Feb 4 21:29:36 2022
++-----------------------------------------------------------------------------+
+| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |
+|-------------------------------+----------------------+----------------------+
+| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
+| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
+| | | MIG M. |
+|===============================+======================+======================|
+| 0 NVIDIA GeForce ... On | 00000000:65:00.0 Off | N/A |
+| 30% 28C P8 11W / 350W | 0MiB / 24576MiB | 0% Default |
+| | | N/A |
++-------------------------------+----------------------+----------------------+
+
++-----------------------------------------------------------------------------+
+| Processes: |
+| GPU GI CI PID Type Process name GPU Memory |
+| ID ID Usage |
+|=============================================================================|
+| No running processes found |
++-----------------------------------------------------------------------------+
+
+ + ## 1. Requirements +
++ NVIDIA’s NGC provides PyTorch Docker Container which contains PyTorch and Torch-TensorRT. We can make use of + + latest pytorch + + container to run this notebook. +
+
+ Otherwise, you can follow the steps in
+
+
+ notebooks/README
+
+
+ to prepare a Docker container yourself, within which you can run this demo notebook.
+
+ ## 2. EfficientNet Overview +
+
+ PyTorch has a model repository called
+
+
+ timm
+
+
+ , which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet.
+
+ This model is based on the + + EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks + + paper. +
+
+ 
+
+ ## 3. Running the model without optimizations +
+
+ PyTorch has a model repository called
+
+
+ timm
+
+
+ , which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet.
+
[4]:
+
+
+import torch
+import torch_tensorrt
+import timm
+import time
+import numpy as np
+import torch.backends.cudnn as cudnn
+from timm.data import resolve_data_config
+from timm.data.transforms_factory import create_transform
+import json
+
+efficientnet_b0_model = timm.create_model('efficientnet_b0',pretrained=True)
+model = efficientnet_b0_model.eval().to("cuda")
+
+ + With our model loaded, let’s proceed to downloading some images! +
+[5]:
+
+
+!mkdir -p ./data
+!wget -O ./data/img0.JPG "https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630"
+!wget -O ./data/img1.JPG "https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg"
+!wget -O ./data/img2.JPG "https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg"
+!wget -O ./data/img3.JPG "https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg"
+
+!wget -O ./data/imagenet_class_index.json "https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json"
+
+
+--2022-02-04 21:30:07-- https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630
+Resolving d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)... 18.65.227.127, 18.65.227.37, 18.65.227.99, ...
+Connecting to d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)|18.65.227.127|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 24112 (24K) [image/jpeg]
+Saving to: ‘./data/img0.JPG’
+
+./data/img0.JPG 100%[===================>] 23.55K --.-KB/s in 0.004s
+
+2022-02-04 21:30:07 (6.40 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]
+
+--2022-02-04 21:30:07-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg
+Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117
+Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 452718 (442K) [image/jpeg]
+Saving to: ‘./data/img1.JPG’
+
+./data/img1.JPG 100%[===================>] 442.11K --.-KB/s in 0.06s
+
+2022-02-04 21:30:07 (6.83 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]
+
+--2022-02-04 21:30:08-- https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg
+Resolving www.artis.nl (www.artis.nl)... 94.75.225.20
+Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 361413 (353K) [image/jpeg]
+Saving to: ‘./data/img2.JPG’
+
+./data/img2.JPG 100%[===================>] 352.94K 246KB/s in 1.4s
+
+2022-02-04 21:30:10 (246 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]
+
+--2022-02-04 21:30:10-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg
+Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.18.202.107, 104.18.201.107, 2606:4700::6812:ca6b, ...
+Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.202.107|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 90994 (89K) [image/jpeg]
+Saving to: ‘./data/img3.JPG’
+
+./data/img3.JPG 100%[===================>] 88.86K --.-KB/s in 0.006s
+
+2022-02-04 21:30:10 (14.4 MB/s) - ‘./data/img3.JPG’ saved [90994/90994]
+
+--2022-02-04 21:30:11-- https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json
+Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.216.133.45
+Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.216.133.45|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 35363 (35K) [application/octet-stream]
+Saving to: ‘./data/imagenet_class_index.json’
+
+./data/imagenet_cla 100%[===================>] 34.53K --.-KB/s in 0.07s
+
+2022-02-04 21:30:11 (474 KB/s) - ‘./data/imagenet_class_index.json’ saved [35363/35363]
+
+
+
+ All pre-trained models expect input images normalized in the same way, i.e. mini-batches of 3-channel RGB images of shape
+
+
+ (3
+
+
+ x
+
+
+ H
+
+
+ x
+
+
+ W)
+
+
+ , where
+
+
+ H
+
+
+ and
+
+
+ W
+
+
+ are expected to be at least
+
+
+ 224
+
+
+ . The images have to be loaded in to a range of
+
+
+ [0,
+
+
+ 1]
+
+
+ and then normalized using
+
+
+ mean
+
+
+ =
+
+
+ [0.485,
+
+
+ 0.456,
+
+
+ 0.406]
+
+
+ and
+
+
+ std
+
+
+ =
+
+
+ [0.229,
+
+
+ 0.224,
+
+
+ 0.225]
+
+
+ .
+
+ Here’s a sample execution. +
+[6]:
+
+
+from PIL import Image
+from torchvision import transforms
+import matplotlib.pyplot as plt
+
+fig, axes = plt.subplots(nrows=2, ncols=2)
+
+for i in range(4):
+ img_path = './data/img%d.JPG'%i
+ img = Image.open(img_path)
+ preprocess = transforms.Compose([
+ transforms.Resize(256),
+ transforms.CenterCrop(224),
+ transforms.ToTensor(),
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ])
+ input_tensor = preprocess(img)
+ plt.subplot(2,2,i+1)
+ plt.imshow(img)
+ plt.axis('off')
+
+# loading labels
+with open("./data/imagenet_class_index.json") as json_file:
+ d = json.load(json_file)
+
+ 
+
+ Throughout this tutorial, we will be making use of some utility functions;
+
+
+ efficientnet_preprocess
+
+
+ for preprocessing input images,
+
+
+ predict
+
+
+ to use the model for prediction and
+
+
+ benchmark
+
+
+ to benchmark the inference. You do not need to understand/go through these utilities to make use of Torch TensorRT, but are welecomed to do so if you choose.
+
[7]:
+
+
+cudnn.benchmark = True
+
+def efficientnet_preprocess():
+ config = resolve_data_config({}, model=model)
+ transform = create_transform(**config)
+ return transform
+
+# decode the results into ([predicted class, description], probability)
+def predict(img_path, model):
+ img = Image.open(img_path)
+ preprocess = efficientnet_preprocess()
+ input_tensor = preprocess(img)
+ input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
+
+ # move the input and model to GPU for speed if available
+ if torch.cuda.is_available():
+ input_batch = input_batch.to('cuda')
+ model.to('cuda')
+
+ with torch.no_grad():
+ output = model(input_batch)
+ # Tensor of shape 1000, with confidence scores over Imagenet's 1000 classes
+ sm_output = torch.nn.functional.softmax(output[0], dim=0)
+
+ ind = torch.argmax(sm_output)
+ return d[str(ind.item())], sm_output[ind] #([predicted class, description], probability)
+
+def benchmark(model, input_shape=(1024, 1, 224, 224), dtype='fp32', nwarmup=50, nruns=10000):
+ input_data = torch.randn(input_shape)
+ input_data = input_data.to("cuda")
+ if dtype=='fp16':
+ input_data = input_data.half()
+
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(nwarmup):
+ features = model(input_data)
+ torch.cuda.synchronize()
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(1, nruns+1):
+ start_time = time.time()
+ features = model(input_data)
+ torch.cuda.synchronize()
+ end_time = time.time()
+ timings.append(end_time - start_time)
+ if i%10==0:
+ print('Iteration %d/%d, avg batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))
+
+ print("Input shape:", input_data.size())
+ print("Output features size:", features.size())
+ print('Average throughput: %.2f images/second'%(input_shape[0]/np.mean(timings)))
+
+ + With the model downloaded and the util functions written, let’s just quickly see some predictions, and benchmark the model in its current un-optimized state. +
+[8]:
+
+
+for i in range(4):
+ img_path = './data/img%d.JPG'%i
+ img = Image.open(img_path)
+
+ pred, prob = predict(img_path, efficientnet_b0_model)
+ print('{} - Predicted: {}, Probablility: {}'.format(img_path, pred, prob))
+
+ plt.subplot(2,2,i+1)
+ plt.imshow(img);
+ plt.axis('off');
+ plt.title(pred[1])
+
+
+/opt/conda/lib/python3.8/site-packages/torchvision/transforms/transforms.py:321: UserWarning: Argument interpolation should be of type InterpolationMode instead of int. Please, use InterpolationMode enum.
+ warnings.warn(
+
+
+./data/img0.JPG - Predicted: ['n02109961', 'Eskimo_dog'], Probablility: 0.3987298309803009
+./data/img1.JPG - Predicted: ['n01537544', 'indigo_bunting'], Probablility: 0.23344755172729492
+./data/img2.JPG - Predicted: ['n02481823', 'chimpanzee'], Probablility: 0.9695423245429993
+./data/img3.JPG - Predicted: ['n01739381', 'vine_snake'], Probablility: 0.227739155292511
+
+ 
+ [9]:
+
+
+# Model benchmark without Torch-TensorRT
+benchmark(model, input_shape=(128, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, avg batch time 37.62 ms
+Iteration 20/100, avg batch time 37.66 ms
+Iteration 30/100, avg batch time 37.65 ms
+Iteration 40/100, avg batch time 37.66 ms
+Iteration 50/100, avg batch time 37.70 ms
+Iteration 60/100, avg batch time 37.70 ms
+Iteration 70/100, avg batch time 37.70 ms
+Iteration 80/100, avg batch time 37.71 ms
+Iteration 90/100, avg batch time 37.72 ms
+Iteration 100/100, avg batch time 37.72 ms
+Input shape: torch.Size([128, 3, 224, 224])
+Output features size: torch.Size([128, 1000])
+Average throughput: 3393.46 images/second
+
+ + ## 4. Accelerating with Torch-TensorRT +
++ Onwards to the next step, accelerating with Torch TensorRT. In these examples we showcase the results for FP32 (single precision) and FP16 (half precision). We do not demonstrat specific tuning, just showcase the simplicity of usage. If you want to learn more about the possible customizations, visit our + + documentation + + . +
+[11]:
+
+
+# The compiled module will have precision as specified by "op_precision".
+# Here, it will have FP32 precision.
+trt_model_fp32 = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input((128, 3, 224, 224), dtype=torch.float32)],
+ enabled_precisions = torch.float32, # Run with FP32
+ workspace_size = 1 << 22
+)
+
+
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+
+ [12]:
+
+
+# Obtain the average time taken by a batch of input
+benchmark(trt_model_fp32, input_shape=(128, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, avg batch time 27.86 ms
+Iteration 20/100, avg batch time 27.71 ms
+Iteration 30/100, avg batch time 27.99 ms
+Iteration 40/100, avg batch time 27.95 ms
+Iteration 50/100, avg batch time 27.89 ms
+Iteration 60/100, avg batch time 27.85 ms
+Iteration 70/100, avg batch time 28.00 ms
+Iteration 80/100, avg batch time 27.97 ms
+Iteration 90/100, avg batch time 27.95 ms
+Iteration 100/100, avg batch time 27.92 ms
+Input shape: torch.Size([128, 3, 224, 224])
+Output features size: torch.Size([128, 1000])
+Average throughput: 4584.06 images/second
+
+ [17]:
+
+
+# The compiled module will have precision as specified by "op_precision".
+# Here, it will have FP16 precision.
+trt_model_fp16 = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input((128, 3, 224, 224), dtype=torch.half)],
+ enabled_precisions = {torch.half}, # Run with FP32
+ workspace_size = 1 << 22
+)
+
+
+WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float
+The compiler is going to use the user setting Float16
+This conflict may cause an error at runtime due to partial compilation being enabled and therefore
+compatibility with PyTorch's data type convention is required.
+If you do indeed see errors at runtime either:
+- Remove the dtype spec for x.1
+- Disable partial compilation by setting require_full_compilation to True
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT] - Mean converter disregards dtype
+WARNING: [Torch-TensorRT TorchScript Conversion Context] - Tensor DataType is determined at build time for tensors not marked as input or output.
+WARNING: [Torch-TensorRT TorchScript Conversion Context] - Tensor DataType is determined at build time for tensors not marked as input or output.
+
+ [18]:
+
+
+# Obtain the average time taken by a batch of input
+benchmark(trt_model_fp16, input_shape=(128, 3, 224, 224), dtype='fp16', nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, avg batch time 12.05 ms
+Iteration 20/100, avg batch time 12.56 ms
+Iteration 30/100, avg batch time 12.39 ms
+Iteration 40/100, avg batch time 12.34 ms
+Iteration 50/100, avg batch time 12.33 ms
+Iteration 60/100, avg batch time 12.32 ms
+Iteration 70/100, avg batch time 12.30 ms
+Iteration 80/100, avg batch time 12.28 ms
+Iteration 90/100, avg batch time 12.35 ms
+Iteration 100/100, avg batch time 12.35 ms
+Input shape: torch.Size([128, 3, 224, 224])
+Output features size: torch.Size([128, 1000])
+Average throughput: 10362.23 images/second
+
+ + ## 5. Conclusion +
++ In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT for EfficientNet-B0 model and test the performance impact of the optimization. With Torch-TensorRT, we observe a speedup of + + 1.35x + + with FP32, and + + 3.13x + + with FP16 on an NVIDIA 3090 GPU. These acceleration numbers will vary from GPU to GPU(as well as implementation to implementation based on the ops used) and we encorage you to try out latest generation of Data center compute +cards for maximum acceleration. +
++ Now it’s time to try Torch-TensorRT on your own model. If you run into any issues, you can fill them at + + https://github.com/NVIDIA/Torch-TensorRT + + . Your involvement will help future development of Torch-TensorRT. +
+[ ]:
+
+
+
+
+ \n",
+ "\n",
+ "# Torch-TensorRT Getting Started - EfficientNet-B0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained EfficientNet network, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [EfficientNet Overview](#2)\n",
+ "1. [Running the model without optimizations](#3)\n",
+ "1. [Accelerating with Torch-TensorRT](#4)\n",
+ "1. [Conclusion](#5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting timm==0.4.12\n",
+ " Downloading timm-0.4.12-py3-none-any.whl (376 kB)\n",
+ "\u001b[K |████████████████████████████████| 376 kB 11.9 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: torch>=1.4 in /opt/conda/lib/python3.8/site-packages (from timm==0.4.12) (1.11.0a0+bfe5ad2)\n",
+ "Requirement already satisfied: torchvision in /opt/conda/lib/python3.8/site-packages (from timm==0.4.12) (0.12.0a0)\n",
+ "Requirement already satisfied: typing_extensions in /opt/conda/lib/python3.8/site-packages (from torch>=1.4->timm==0.4.12) (4.0.1)\n",
+ "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /opt/conda/lib/python3.8/site-packages (from torchvision->timm==0.4.12) (8.2.0)\n",
+ "Requirement already satisfied: numpy in /opt/conda/lib/python3.8/site-packages (from torchvision->timm==0.4.12) (1.22.0)\n",
+ "Installing collected packages: timm\n",
+ "Successfully installed timm-0.4.12\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
+ "Fri Feb 4 21:29:36 2022 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 NVIDIA GeForce ... On | 00000000:65:00.0 Off | N/A |\n",
+ "| 30% 28C P8 11W / 350W | 0MiB / 24576MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=============================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------+\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install timm==0.4.12\n",
+ "!nvidia-smi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "NVIDIA's NGC provides PyTorch Docker Container which contains PyTorch and Torch-TensorRT. We can make use of [latest pytorch](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch) container to run this notebook.\n",
+ "\n",
+ "Otherwise, you can follow the steps in `notebooks/README` to prepare a Docker container yourself, within which you can run this demo notebook."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. EfficientNet Overview\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called `timm`, which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet.\n",
+ "\n",
+ "### Model Description\n",
+ "\n",
+ "This model is based on the [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946) paper.\n",
+ "\n",
+ "![\"alt\"](\"https://1.bp.blogspot.com/-Cdtb97FtgdA/XO3BHsB7oEI/AAAAAAAAEKE/bmtkonwgs8cmWyI5esVo8wJPnhPLQ5bGQCLcBGAs/s1600/image4.png\")
\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Running the model without optimizations\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called `timm`, which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "import torch_tensorrt\n",
+ "import timm\n",
+ "import time\n",
+ "import numpy as np\n",
+ "import torch.backends.cudnn as cudnn\n",
+ "from timm.data import resolve_data_config\n",
+ "from timm.data.transforms_factory import create_transform\n",
+ "import json \n",
+ "\n",
+ "efficientnet_b0_model = timm.create_model('efficientnet_b0',pretrained=True)\n",
+ "model = efficientnet_b0_model.eval().to(\"cuda\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With our model loaded, let's proceed to downloading some images!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "--2022-02-04 21:30:07-- https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\n",
+ "Resolving d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)... 18.65.227.127, 18.65.227.37, 18.65.227.99, ...\n",
+ "Connecting to d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)|18.65.227.127|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 24112 (24K) [image/jpeg]\n",
+ "Saving to: ‘./data/img0.JPG’\n",
+ "\n",
+ "./data/img0.JPG 100%[===================>] 23.55K --.-KB/s in 0.004s \n",
+ "\n",
+ "2022-02-04 21:30:07 (6.40 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]\n",
+ "\n",
+ "--2022-02-04 21:30:07-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\n",
+ "Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117\n",
+ "Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 452718 (442K) [image/jpeg]\n",
+ "Saving to: ‘./data/img1.JPG’\n",
+ "\n",
+ "./data/img1.JPG 100%[===================>] 442.11K --.-KB/s in 0.06s \n",
+ "\n",
+ "2022-02-04 21:30:07 (6.83 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]\n",
+ "\n",
+ "--2022-02-04 21:30:08-- https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\n",
+ "Resolving www.artis.nl (www.artis.nl)... 94.75.225.20\n",
+ "Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 361413 (353K) [image/jpeg]\n",
+ "Saving to: ‘./data/img2.JPG’\n",
+ "\n",
+ "./data/img2.JPG 100%[===================>] 352.94K 246KB/s in 1.4s \n",
+ "\n",
+ "2022-02-04 21:30:10 (246 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]\n",
+ "\n",
+ "--2022-02-04 21:30:10-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\n",
+ "Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.18.202.107, 104.18.201.107, 2606:4700::6812:ca6b, ...\n",
+ "Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.202.107|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 90994 (89K) [image/jpeg]\n",
+ "Saving to: ‘./data/img3.JPG’\n",
+ "\n",
+ "./data/img3.JPG 100%[===================>] 88.86K --.-KB/s in 0.006s \n",
+ "\n",
+ "2022-02-04 21:30:10 (14.4 MB/s) - ‘./data/img3.JPG’ saved [90994/90994]\n",
+ "\n",
+ "--2022-02-04 21:30:11-- https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\n",
+ "Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.216.133.45\n",
+ "Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.216.133.45|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 35363 (35K) [application/octet-stream]\n",
+ "Saving to: ‘./data/imagenet_class_index.json’\n",
+ "\n",
+ "./data/imagenet_cla 100%[===================>] 34.53K --.-KB/s in 0.07s \n",
+ "\n",
+ "2022-02-04 21:30:11 (474 KB/s) - ‘./data/imagenet_class_index.json’ saved [35363/35363]\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "!mkdir -p ./data\n",
+ "!wget -O ./data/img0.JPG \"https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\"\n",
+ "!wget -O ./data/img1.JPG \"https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\"\n",
+ "!wget -O ./data/img2.JPG \"https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\"\n",
+ "!wget -O ./data/img3.JPG \"https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\"\n",
+ "\n",
+ "!wget -O ./data/imagenet_class_index.json \"https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "All pre-trained models expect input images normalized in the same way,\n",
+ "i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.\n",
+ "The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`\n",
+ "and `std = [0.229, 0.224, 0.225]`.\n",
+ "\n",
+ "Here's a sample execution."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9WbBnyX3fiX0y86z//e639qV3dLMbDRAEARIkRYmklhmt1ihmFKMJTThke+wXP9mPEw6Hww92+M12hB22R7akkWStExxRJEVxARcQaKDRDfRa3V171d3v/e//s2T6ITPPOf9bVY0GOQWhwpXdt+7/nv9Z8uTyze9vTWGM4Wl5Wp6Wp+Vp+dEU+R+6Ak/L0/K0PC3//1Segu7T8rQ8LU/Lj7A8Bd2n5Wl5Wp6WH2F5CrpPy9PytDwtP8LyFHSflqflaXlafoQleBw3/Ue/9x0znU6rv4UQCCEAkFKitUZrvXSNP0cIgTGm+mkeF1KAEEgpMRrKUlPqkqTVIQwiDCWBCkjTDkmSEAQBSoWEYYCUCikMKgAhQWDA3VcJgTEarZvPMygpCAT2Oimqei4V5/0hDCDw/9Rfu0MGKAFjTH3w9LkNTxL7HONubD8adyNjDKUBo0FrqnaSUoAAXRqKLKfIC/IiRwBhHCMAnRcs5nNmeUZh6j449VYPFlOf49ug2Ra/+OK5H3iLp+VpeVoeE+gqpQjD8FO/V0oBNWD44j83QdcfN8Ie11ojkCgpLWgqRRCGSBkQhiFJkhCGIUHgwFYKpIRQCZQEhFkCciGgLEEpgUA4AAPpQFSIh4BtXWFbXwesmAe+cmAqHkA2+37V2QhRYfgPLELYZ1ZtYwzGgEBgtAFtMGVJvsjQWmO0QUpJkedkRc5ndRX05/l2afaPf7aUTwWmp+Vp+azlsYDup03CJnj9oIl/ekKbJjNzQIMQSCEJVIAKII5iwjAkDEOUUkhpma1yPxZAqY7be4HxnwGJsUy4OmKx1Ne8+c0Db9AAVrP054N/2XfydfAg9pCbPKJtxKkTtLb11kWBLgqKPMeUJQLIFwvHkA2l0RjLmx91+8brCLdeiAcWR98/j1yQnpan5Wl5oDwW0P20Sdhkr6dBVwgPdcKJ/tKCoxAWUIwBx4CRFsQCFSKEREmIVEAoA0IlCAOJklZNIISwrLUC3BpAhDAIrIrBCfC+NhaAHRiaZcz8k7SK1RRUaNsAPGEa4CdOPeYhDz3Vvl4qACiKEp3nFHlOWRTVe2oPuLqstRuNJ1QA2riv1h6cxUP7tMl8n5an5Wn5bOWxgK4vTd3tkm62obc9PWntdwKtNUEgkFK5c+x9jNEVwGhjCJRCBQqlJFJYlYOUElkBgkc6K48bLCOUjvVakdw44Flm6FJ4FcPD9K3u82doB/tOy+ca4eHVU92a9TZF9+r801KBAXOKpxpjKMuCvCgoygLdWKRKYyjQjbZgSePh1TRN2C0pl/qvWYenDPdpeVr+ZOWxgK4xhqIoKMuyPihqDndab2sNXsqCMPXkVkqhwggQ6LJAYDClrq4VWHYWqMCxYolU6gH1htcDG6RjuYBTIUhnnHuYoG1YZpFV3R3trXSqn6E9HqZaeOBh1QevODBL3zXroc2D97UqB7fYBJJSl+hCY7S2cCuWkX9pEWi0efUMrR8A26c63KflafnTlccCumVZMyRPqgBwzPa054LWusGcLJAIIQnChDhJLGBmgrIsKzZq0AilKt2mMJZ9KSkt8Ph7G1PBmKwYLU7VULNh4Rixv59GoI3n1/Zuyj74tHR/Slv7qGIqnvlgEY1/qR5gmlzWgDZWzeLPEXYZWmpHjcEIkFIRBIbCmIaXwiNq6bBYGAgCVfVRWcqqr5qeJHU1nzLdp+Vp+WHLYwHdxWIBOF2sqaFDCFlN3NPA64sxhrIoUUGEkMp5Hyi0NpiyqCz+xgiEssxWSIlwlrESgzAajEDoEuN0ul6fKyQIKZDSuoE5/F0yFgkck2TZJctIgRKmuqYygvGgqO/fv3ovGp5iS6d+CnA5FYIxouEe5u+9/IyyLCnLsmKlUghQyrJVbdnuw57kVRxCCGuAjEKEEBRFgWjohP2zTgPv04RJT8vT8sOVx6ZeiKLIivXGoB3TUlKhpHS6x3JZjdBwIVNOReANPF7fWKoQg0CXGik1KlDEcUwUxagwQgQBQgWgrOgvpEQ23MOktF4LUnl9rUGaUzyzYeAyBoy2jLcyvDklr1pyMDA/kOl6MP/hQcrqg/1lWludtpcMvH+uV8809eRe4vDqntN+z9UTnJQQhqHToXupQWGUNyQu65lPq4ielqflafls5bGAbhRFS8Yy7X578R9qZtYE1eYEDgJF064lhEAFgWXJUiOkIE5ikjgliiJUEKBU4AxqoJREKeu1UFnnhXb+twYlbDjeaRctI7AiurFgp42pDG/GWAC2J9ZsUzZUKPZ2Xj3QKJ8JmJbB23sOSAFa+LpodKkxUiOUtAuUECglEcLqxr0Bs6mPrQC/wej9F8JgdeHKLkz+FaQSKFSjQvVbnmbxT8vT8rR8tvJYQNcGJcgadB3b8seFEOR5vsSa/Plaa5QSKClRgSJwYByFIRJDKVywglTEcUIURQRBQBA0giACVbNaalbmAx6EcxUwS0aiWo9ag26DqRuJ0BYWtXR63IYjgGygZRM4PQh73fLpsmykqmvhrzVeL+EMZ0ZryjynMAYZBBCDEEHD7cu/q6wWNitFmCXgP81YpfP6qNUW1rXOGPHQ8wU2sEQ59c7T8rQ8LZ+tPFamCzwAuqd9dE8baPznIAwIg9Alh3B6YAEicOJ9YKPPLOhKhLQgIYXVu0oHztLpcYEldygjKtOZwyLjnBKcZ0IjxLaKghOBra92umHHkmt9rXDGtoe7wv0gtmuMdyV70DMBgNJ6b+iiJMsyZOBUAY1Fq3pWoy0rj4NHuHxVUX1B4BizB3B1KjS6qd819X2egu7T8rR85vKYQDekMi8ZMFpjjBX5eYSPblMdgRAWAKSf7KCNtsCKQEjp1Af1jw+i8EazKmeBaN7fA6WpwNZo736Fd9oFvI+xVS04TLZGOp+3oVoswEgwso4Qk04x/DA9r3nggzPCmeUYuKp+rlperaCLkrIo0E5fW6gA6dQMVSCEflAPK4UEYVU8QRCggtrzA+EkC6UqHXgQyMpwV7ebb8slv4qnoPu0PC0/RHksoBtHEeBZrsHoWqfrj4vAgbArVWCAQyslFcIYO8FNiTEFAu9aZnXDgRSVblY6OV9gMMKgjXUdQxvH3Grg0Mb+o52hrNTaBRLU76CNdvWuagiA0B59SusFIaTThVqPCA1IZAOkmuz2FAw7TwbtdMdGi4pB+hM8yy4LTVEUFEVOWdaqmSLPkLnCSwNC1MY2nEeCD5+2KhdVLVSV1IHXe1u3OF8H7aWB0yuF8OEkT275V//wf2eM86ypu965F/pX88edSsr2buNL0fB+qVf3uj2b96R+xnJwjaju3xwfVlKT1rf6tLFXehWZldgwBlElDLTvpCqfmtql0nv+2Mwl7r5esjMVFam8Zqxnu+9/gzEaUdld7J01ujlAcDMQV21KYT9rR3asK6YLVzcCIzTCWCnW3te9R3VP41Rc2jWixN/c9o12rVi3MEJiTOmO2xlpRF0n13sYNBLbHrbW1h6kAWGac8O2rhESYyRClBhj29DgRV4XuVnVQ/Cf/p3/+qGT5LGAbuJ8ay07q9ULS4YdKSqvBjgteRuEsFFltuttg3tx3npDqSVH/lpdge0fYY1flauYqCdJxSwN6BJKTWXsA88U68FVP6NpnLJ1FI49SmmQynWQsN/Vda4nV5M22gXFLky61JZZat8CNSu3oFtSZBlFntl7uJcrnWeCcEwVfD2s2G8XOoN0BjlfL9kMlFgykNW9UOWm8Kf4geje4Ul2WvCg0vxbOVCAxjjxYeDVUWt5FKeyojYNk6fFmcotDztxbZEIoavvhZCNZ9aTVxjriaOofcYrNZnwgGG7RjpwCyo9vKzBoaq6Vb9VeqyqBu4NRQ3Owgi0A+LaQ0dU49YIgTASY40dNcD793DjrhT2LiXYUH43tyyWC7TwwGqqt3ww66xw429Zgq0bXNg29co+IbF5/URlF6kXVgviDk5cF9t5oo0lTc0et5PC3lmK0rWJxIg6JsAsV+pTy2MB3W63S57n5HlOWdj0i17FUIGuEciGSN0cBAKQQiKEwghTuW0Zn1XMhQYbrTENg10TeCuvCCFcJrGmTtKL4TYNovUKsOJ66TJyQb3ye5WFcanE/IARnqE45i28igOv5qhZtmX1xgGxrDrTOMAty5KyMOR5WXke+Gu1saCrdYE0hjAIUFFs2aqLZ1YqsO2itGVJUjgvDjvoJMK6xwnf3DXAVkuLWWb2xtfRHa8Gr3FTw0snD9M//9gXywbLairWXAUa7WAcJFVzuwasaiGl2bD1YgmnLK5LwAUgbVrRZrWEd5Wsp71np4ADYYOsALEGfCEcIAvHUKkB11ajZnwCC3bCWKCyAKrdiRpjPBDTACZwPNDWo6q5wAhFrhUloJAYkxPI0r2DcZzQLWrGVNBaW4obg3EJSJut4445hlx1UtVYjVwhACj7t/BAX/e0BWVd9YVBV6CunSwAVpK1c90tKW4u2WcptwD5VnDk0MjlPj1VHhPTjQjDgKKIyLKMLMssk3NynE3NWFvG64Z2lRfN7FUGLQW6rNZiB2xW3EGXlLhwYyMr3axn1mUFQNaVodZ76hqsyxKtS4qisOqQJaZSG5K8R8Npg9XDXLHqHLcSqSAMVeVZUEXBVYBmo+3yLCcvCmx+Cft8T4wF1rgYRSFRFBKGyvoMa0VelMznGZgcbUqyPKPISqQ0pGlEmqbEkSKJrc4WA1pYw5qBJeCpNNPGDu7KWOiYggdfW0fLAPSnjbAf01KxOFPBYzUMmxoe4Wi+qEiBZ3MOeAVgvMTlEbcx9YVjVh6kXVvLCrAt4zVu8lcATy2s+qtk9Z2ygCgsYEo31qxYbNll9STPmo2VGCXSpUgF2WSOph4DVXy7O15DoHDc1aAFFCbiqFzh5nSLg6zL7jTGFAU5AlMuWA3nXGjtcnXliE4wsXcx7l2N58KeI5YYo7DqAsfw/bJSLXQWJP24q20LdiGqWsx4UKR+J/cU359+znq+YIyVUHUlJThpRjiOa04rgOp11p7XWDhOjaHT5TGldrRszmfz0lpTihJRmorF2Up7EaJemyrvBecGhnDidelyORhpI9WE10tp68olLAgbbUNlfd6HCvikRKgm0NVqD12WaBft5vV8otG8tVuXbHymOl+4OjYXbGtoUwihUNp6VjQnp6Go7uPbI4wC4iSs2sWraLznRxha7wIV2MEwGs5YLEqKogShybIZu7t7nJyMwQiOxxOuX7/BpfMXWMwzLl2+wHNXL3D2zCpBI+ihNJqd+4d8+P4dvvyVl4mTOheyF/s8u7dGvZpkaA1lc5I+IUVXv2u9pTe2AhYfHCJLBzKW+Qg3oUQ1MY3wZKvOkue1N7qah14NIByANyU752mDtDpad9ROXuNrCLhIw4oIWFblmbWXnvwdpFsofJ6SWs1Ro4K3HVdDd0mXWi9GtilMtUBMzAq/f/gy741XuDvWxHlGK4CFDhlnObNFgNY9ZouEvtjkz1055mcv3iKQmdO3esit2asFXlkx44ole91Is/41Bavu5QP9RQW4xq2D9lojrBrRNq+ujgl8NkGvTvBd4KNPhfssMFUOWE2lvffqleb68Clj7zGldqzHlAlsQnOtDYg6GMKeV4OvFPU6EoYhcRwThJ6+W/DJ85yicEpsd420o9WqCEpDWXWXLU3Vgym9jsf63lq/V+MGAdbvVEpnFLN8wetbS+fNQD1Mlt41UAKfdKcZKWajxaTLaaCqEa51rTfyi5O/Vko3eSux3tQBEMoGluzsnXByMmZl0KHXgsU8Yz6f0Y1Dzj93hcODY44P9nnpykU+/xMvcP/eHv/gH/1T1rY3+erPfpVz5y9wcjzk1s0bZJM5rXbCiy89Zxl0xdap3rduz6qX3QIHjbRGT1BpqqNqsdL3rJ9AiIaE5VieVzfJapLb+wkcSPr8IMKBpPHfO6G/mpS1gcYDr3Hn2TvIKrWo191CXR/pJngN9A0EtYf829TgX51i1Ql2Ia1DxJtwBqZSq1TAZSSjPOa7e2f46Djkjd0xk/GCJArIhCA0kAaGeWHQiykLJAeZ4v/+/bN8/6DLf/7y+3TisZ1bPhuJse/qua/9UVTSrH9v4xccp/4Q9rxKTYAGoXxzO5yulCwOzD1DXpY83IhoqCBtSzeoV9WgwgO8F2ywGGZtT8K90sPTHMDjYrqOwmvnfqSCkNCAyTIKk6NCa0EPfLivqFUJBlAqIAqtdwJCYpCUxgYDqDyn1Noa0qq0jxY8i0JDXtjMWl48lk48WjLaGevV4BmDlAShrCLaPJMwxqAL48JpS4qGasH7xtqQZQuI0nkE2Ny9jcnoFodaTeHusyTGOuAVGp8D2BoZLGsKjaEUhsPhjLff/oDeoMvWap9erDBlwTxfsNLrIGWPyWzG0eEeV7e3iOOQYjZjc32F2eiYj/Z32bt7g/XtCwwnCy5sDPilX/oFtrfWSdsxsXI8wy35VVBHk7YZO3l9Ap8nULuA548l1AY146L/PGd1beBZbKXXq0iCceKqcOBsZ6HnahWhdH3oOdpS1mIhlwJ4rL3XMVNTqyashrH2PrDMUDvw9X3m+WytEnAPcXDfUCG4PrZivHCU18Gem79erEYKSg3DMbx/Y4gINfPb/1+ufbckUy+RRc+QGU0ic/7j1WPmh9cZiBb/OvkiE5Fi4pDCwNfvdjmevMDf++I11tJjaNTTqj5qacpUTNLXt8Dzbss2/dvVemM3SKt+acJp1RJOv+u9EyRWzeQXqAqYG1faOsrq+xq863pYbbVTQzT0vA8rjyefrtd5gt21IRCATaQSRaFLx1i7LQnP7FyxAQ4QeLYsBMoISgGBFBXza65KGuNAU6GKgrKs+b43btE43z9HuCg25dmtA0rcL59CUbv0iODYraFWobgkOkJ4sdLU53kApmmPdfrhpWlRsyfRGADSlCAk2gju7w75/W99j6PDQ37xa1+k305QlGSFIVABMlAMj47o9Hq0woD/7p/9c175/E/wE194jVs3bnC4v4PWmps3PuTihT3+yt/6W2wMuuzcvclKP2VzY2D5RQNQpdeBY2VNYdyLOA8eIVw++SetGCgrJl9xUCt+VkzIZ7Rziymmag9bvJHFTvZKMBf2O0cRHYt1i3XFjH1j0niSHeP2o+e19diAhlZV+OtqEVk0dfDOYLakq62ehmNjnvNSM1rcNaaOANo/nHP91oSVwQoXzp3jmeef4923ND91519z7f63eO/wCkkwZVv1efvWTcTKJuNrb/ILv7zFv5hdRecCI9uYcs47xzH/xz/+HP/rL79NNx0tkaGa02q3GFAvCP4thDtTeAnFzTfpvRS84cx/V8No86hpqJIqG0t1RZPv++tqplsx7sYyVi1yolZcPao8noQ3+AlpmUNQiduhraDb6UG55AfSMwL/XtL73tYTWguX40A47zgv8hj7XekHnlDIQKJLoDHYfcPadvNigj2u3L1rxXj9HpZVgDGyamIvClbv2LimoSWp71Uxl0YbPaBpd9N86Vo7wbQRHAynfOt7H/DJjZv84s99kfV+i0hBnhVMpxNKbcjmGZ1Oizs3b/D7v/3bnAxPSDptPvroI373d7+OknB8uM/6+iYr6ytonfF7v/3bfPVnfprtzQ0SF9RSDXFHxn27aGz+Ya3rd5JN7HiCijHe79agwOlSDbXRzLsUiRqIHOOt12/j9LDGAZ7wNM0toJ5zagfc7rz6CO4RtrgETLKh0rBepjVvNR7o7QVOsG4a+qgZKjW7tezOM0k32YRXLQh3Zn2uERKzKNjfOebgOzd5KYoY//G3WRQFN3/5ddaSFf7nf+ev8uZ3f59/8eY+OyczevM9vnd4yMnN6zy72uZCdp/B4GVOTIo+mdmsd6Xg+gH8P751mf/qK+8TBXNniPXP1g1ANEugXAGiEbhQpWrB8N4UjqRX/r/VClPdX1RtUUkp1bf1zK+nca3YwX/y48DZbTBNBVuJ+QGbrD8W0HXOFLUVVRiUNBjp120Lhj42woJuk/WBf0GJndQSD7q2UaWsG0DjBqqyng6lEbXNqoGAsmFkEMJU10tjlkS8JdR09be90uCqov4tGoO45idmqZv98333amqf5SXNUcW+vJZLsD+a8403P+SjT67z/DPnWO0mhFJa391CM1/Mabd6tBPFdDFiOhnz9ltvs3NwTPpHbzBdTFhkMxbzGbOTE9rdDiJq89233iNE8Mxzz9BJ0woErDuZ03cDRrt+E3aBs4uRbUNZL/Gnh8GPdTGidDhqgcsYkEJXi7Ifvd66rZqGiqaCQDieKrT1k3XHMKYC8iVx1S/W7t96TIjGteDVU7Umt/JAdYu8/abE38/d3wm6Vh/afGGo7+a8AnTtBuUNQH5xkQjk927ypd/+Q9LhDpO9EbNWi/sXz5D31wnTguNbnxDv3uFXLvf51fc6DDnhb/9sm2k246eSl/mN6AqtMqMoSuRKyImJ0SdzQPKt4xV+9f2L/OWXriHcAqcr10PvpeAr7t/OL15Uf+NJkSNz/rhfOKlQyC5GfmadjlhtNBJeKl6SgYTEbqTogy7AWfCrFscjljl93+Xy2NQLHhwrNinrQQNOJ+o+e1CtW9MJFkIg61zo1deefTUh0hok7MFHuTCJpc81y6jDYRsVbF7UNEc2G9QfrthQ4zvn1F7driF7WtBqMIuG9V+4FbzQgsks52g44Y+/831OxjO2N1Z45tJ5umkLhHUzWywWSKlIWhGLxYw7O/f5nW98k/aZS3z+lZ8kL0qEFkQq5MzlZyi1JGn3EFGKiju0kgAZd20eh1Ov79vF92Xtp1tnjrPs7skLA66ZlLAM04GUz0rndbh2saknlMKzTx/Z5YDO+bU2xXtvaRG4nByNRc2ySVE9C6gNYUI29Mj22caYxrBzxxxhsAPx1CJvGsPZi8MVAfbA5sDKq7pcBwsjkGXJ5T/4Ptsne7Bxhdalgna6xuWXXuOTL/0FVJoSBQEj+X9g5/230eGXua6njI7us722zdvlBRYzRdgTbAUFkyBilmcsAg3YnB6/eus8l9I9XrmwTxDIpXrZKCHPQhts0+iqvRoiAl4hVi9wtd+txQvXh8avMP56L1M0Jq9YcrqryVjD39qCq4+OkwhRWJc3HLh/ikfPY1Mv+NVHGid+Czd5XZ09g/XFu8AADdHb0NBVL7GLJj+sVxlOnfiwmlWwv3SvT71WnPpw6hq/jtaAu4zc9qmGUtc313Lpyup2JZJZrvnk1j7f/u67HJ8cMhoPuXzpHC8+e4mNlT6htIEh3i1usLJClhd8cO0Ov/eH3ybTCWvblzg43McYw9aZs5w7v4ESgg+3z7C7u8/WhUvMZgXjecbb71znmQvbRPJUOz74KktCKFCFeD9pTFf4SeoHmABh6lgk6ZTXfuFpSkl1Kk/n+Wp8OKkbi84rYMnmIAwI6SZcrTaop7FlVxUvM1Tqs1IYAvd0r/sFGu3eEI4barBKleAlKj+vlvrUuWdVeOQWg9mU+RvfRj93gWQ0JV69xIIS8d3f4dv5jHxtjTSV3H3vGm/d7TINtyiSi9zVBXfDlF4kWC3HtOcjZkjCIqMddBGRZIGGMGVawj/9+DmeOTOjLcdWVPfAaFvtVK/Z961A2Ph280DtPROMa78G1zFeRmjey/2uhq9vH7/4+UPm1DUCKKsHCGGjQEtZQC5PXfNgeTzeCw1tlhFOrSCw+qyGka05WCReLyUqNlhBwAN46lvDuOd9+pQ3zbEmHnZmwz/TU4T6L2pezHLnPKpUz9AVC9I+isn4Hz+AoNAlo1HGZLrgxt0Drt24w5079zC6YD49YTDosrU2YKXXIpSG6WxGFEUUeUlmBLv39/nw2idc++QOWrWYTA6YjI4YnxwTt1IGgzY/9YWfYNDr0mm1uHV7l1e/+Brff+cTbly7SVYUVnVQBdrXDWCc5FAKnyNC1AwX56r3aabaH/NS81azNDZq4BUoUYOv734tHLM1tRjvPVNqX17HobzXQwWyPsTAVDNFiHocV6EVriuUqUd99cHU53ojYLUkOsJTTREBOMnEM3PrfVKDybKLk6Fstzhab9P75BbrnZiwyGCtw/Gzqwj5Eff/6Nc4GilOxori7F+mGyhanVWKg2PkYoGJEwoCBhR0VMFdo5kYQdJpoVHElCxkwN3FgH954zX+9nPfRFBU+mbjfYxrOYB69tcMFVFSq3sqKu/ucZoMlJUeV4hGG7nr6kXSyTHemGeWPRWsd4IfM/YZRSHQ4Qzd0USmS6vdeeSYezx+un5VrqJEqvo2xIQGUxUNVmAa14jlJqvIYSUa1Pf7VJ7lG7iuxtKnB5cAls6qr3z40x5Y2Kp+t4MhcDcxaEqsG1imYTpZcP/+AW++9SG/9wdvECcps3zC6mqf6fiYo4N9VgY9Ll/cJk0iyjyjUIpFWTAezjEaFmXBZDyi3+3wk59/hWuf3ORwb4fNrVXSJGBldZXXXnqRFy5eQCrJlcsX6Q/WeOnZi+zdO2HaP+Y/+jM/SSSN1YX7Nm+8jxfcjF8MRQ28Uj6ZEWkAtQvXsutQgKhE/+YU9+DmdZA+eKDEs19T6YcFzbFvyYQfZabycrGrsOPU1JKU9aJQDXWbtYPUaoamt0EFnS422/9XGZL8ABXUoCaM8+l3XjmNnB/oAmTA7H/2N/jk//QPCRYTWvs3uV0MuPM//Sucyec8e38PjOCa7PKv9vcZXfk8CQWTOGRqIlZGhygzZ8qMTCnuD55HLOZkSQfVCgnDmBRBnEhuzSO+f/AiL6++jbeo13PKq2Ga6pO6XeqoSerrPFAvhejWc9z3iahUMqK61p5lgbypVfQ2UqDhsiaWfHVV3kKUM8rBAYvkR8x0qSrvxCVTH2mu0t541XTT8sdxh/ylAirLrz1klu/5KexziTU/9ITaCdwhND53QiO2pbLmN6gNVO/hv/ecwTEhDCWCRV4ymWUcHg25v3PAt998l2984w12d/cIQ8WZs+dotyQhObt3btiQXZMxHh3R7SREgUTnBTPmHI9Hjj2XbK6scHZthXbaIlCKL/3EC5yMv0KUxBwcnRDGKWv9FmkEhYbFdM6gm7LWTXj9c8/xyz/zKqu9FG940afIgVkSE5rO46L6/qHCw4958Yu6Mk4ag8oDwfu72n61s0oKbIY5pxi149Ht6OHu6JmTdrkPcPeugdughSDAg7RAGEHwkPaT1SxoQIxb6Cr965KtwTNE/7fzzqjcm6yU6ff+owJo8D65puKVwiL4lUuM/+v/Ce/t7tE/uEt85x4agQpj4gsvcGH/+6xzxEfpIb+ZlwyFQAeKIrP67gPZIj35mHnnImb3DgUxuruFWECqIJYFl1qCQay4MbnC+fYO3ehexcz9u9kgEKdSEALMabVD1aNUYIhx0Xqmbrvm0laxOt8g9UK5TOiEbSxv0KieUYkQS3UQZQxHiozDh9TRlscHuk1XMD9BK4x0XStANEQv3wbNMbj0mmJZ1KgNa59OtcQjPlfPaOCIqJYue0/pY+epRR3LTHwYoeVI3h1HA9N5wfBkxp07uwyHM/aHE27fvcf+zn2OD4945+23yXRBb6VPf7XF8z/xKu12l+OjA1hMyRcLxsdDtjbWODo+5PBgj7NnN1mEAePplNwY9g+PGQy6rPa7tMOAQCkEgqQTsdpdozCag3s7/F//L3+fF154jv/i7/x1FouM+TRjY3ud8bhkdaXNhbM9axMwyy5tvlRBAK59jAEjhU3Us2Ruf8KKcOkPqwVbIKQLzmmM1yo/c20VroIWtMTlOqBmoHiJ0wKsdPexRi9HFkQd61RLFrJiXsKcHqX1SugBt9YanBKxhKH2irH/CpfCxYOF8AuNqVmxv2flu2ks4QhWumQrA3a5itAF2mik0GTnz9L91rcxa8/zRXGZ320PWOiQMAkx0xHz4Q5Z3EHGWwxFh0gawiQkHn9Mv9fi4uKIC+khz/Qm/MSZKaKn2Ly8x/gk5O6dmGzu2b1szG+32FAbvqyxWrt3sovmkq2oBh37S1iJrfKld0RpyUh/6lmIJg+ulybwWQfr1rbTJUAe9x859B6TeqGCxeplT0vfPjKkpr4NDwJ37ek8B7rBLE8/71N47EOLz5lgH91wdG5UQhiB0II6yto4v3HDdFGwyAuOT0YMTybki4yD/UO+8Udv8P1334coREtY294GIbhz/Rrjk2Nm8wX9wSorcczGmTNcuHIVESiEKZieHHB8cEC+mJPEIbdufEKrlXDvzm3OnjvDdDwhLwobDo0kmkQUhUZEXudo/QaNsS5Ozz17kT//Sz/L+x9+RF7YpEOXL55DCMn33/6Qr3zlBUJlV3Lv/1m1aUPdo0Q9SP3C8kM2949d8TpV5UJ5EbWaATwhcAoCu8pWoqxnh9I4DukmZWnqMV/fx+14ggUEm/VL1J4K1YB3umX/Z9OuIU5JHNVArXvMg4cXyZZhFwcgPgVjo1SLhXWLMqZ217JSm8H6nmogAKPRBibtGKEUwcH3eGF9wOv9lJuLiMOpQIspetBlPb3D1vAGl/qKi9036cfHtM9KyuhZtrbHdDbfI+1mtLua1dUOa501dJbz0su/wPvv9bj1SUlRONe5SsdLDZiNNJC1K55rj6V/ar9b0+jDiuw2BnPlqNBovVpOMY1VFddOzdasJeDiU+wcj43pLlXiITP0f8g523y/psX40072lmGvq8RY3WSel8zmGcfHY0bjKTfv7HJ4PCUvS3YPDsjyHK1hb+eQ6XjC7s59xuMjRif7CFMwPLzHbDokSrtcvvIs09EJW2cv0O90MeWM7bNbHA9HhJHg6tULbJzd5PatW9y5eYPdO3fZuXubOApZWVtlMZuiywXHRwccHuwTpy1OToZkWUa/v8Z8VvDGd9/hJz//OXrthEhaAUo7AEmTiF/+pa/xtZ//CnEcoNqSJI3RSJ45d4Zupxkw6iP3Ti2QDeOQMU7U43Rk+ZOKwC6KXtQqIRf1SvOdLBN1LdOQxKqJa/ySJSviXE1s47ODnbZviDqgAlONR+8dapYmtjvHLCsBvN62UoEZ6smwJA77qgsrmjsQP82SLeB6Ebt0l9ssw/b60o0Ug5Gwf2GVC5M5O5liOJkShAU/u/VvOXv133EmvcH2mRntRKAKQVHkbJ+FOBUU+R1UaEgSkJlBlFCOh5Sxoiwk6H/Jq69e5eqV13jrO13292yD2kVR1jkbGhBbLVHG92tD8qhaq+6TKljK81qvujHLGCIaY6EiZs72wSlS6IljKQy/ceM3+Nv8708POOAxgq5fKSs1gKlXG/8ila/tQ4GyQfkb1nLf6V4V01z5/Llg0FqQFSWT6ZwsK8izgvFoyiLLOTwckmtNWRSURcFsvmBv74jj4zH37+8xm8/4+MYtToYnpElAu9MlTlrIOKCVtmh12syzGWknoVumRC1odSIO9+7RXd2k21/h5HCHD9/+Fq1On9loH6MEvcEq1979Pv1+l97WOqtrKwhKpuMR4+GQxWyC1AXDoyFxFJKmKQd799lJYsaTKUGUsHPvHkeHR2xszTh78TL39/a59vF1nr1ykUE7AYnNqgbYPwyt2G6triT0WpHd+VeCMorS67xOtX1dlg04NWOozzkNUk9GcXkuKrA0VQCEDXZojM8lAG6YdGocxuuAG4IwIJyKob7eu9svnyUaF9bMuXnctrlu+Nkuj3xj/L4WHpRNdYY/x6VkqdQKdf3rz00gEdQ7Q/iautmFETC+8grXb2/xvwl/jlj8Jv/LL/43nDu/Q3cA2QwWC0ErhTgxXP9EMJkaytLQTSRJakhbIUWRkSjItWFv/4AkbaGyGeOTd+it3OMXf+m/4M3vTPjoPY02sjLO+7b0QRA+oaWXNHxmsqZm3AeSuBMeii8yEFWAWR1OfGrHkMYvMJwmtR+cvMcnh2/yqPKYma4tVf5ZTB1NI5anabVmNVcQt7r5UFzv36yNZ/gGb1DQQpAtcj75+DZvvPku337zHW7d2aEUEbnOGE6OMGXJxsYGV5+9SpykxHFEmc05ORpy9+5dDJrxaEi33+fln/wcaadNFARkWcF0MuVgb5f5+JiynKNNyXw+IoliiiBABCFnLz/DbDZFGrjw7Isc7N0nm08J45jB2irT6YxOq0XSSrn87BUClyvhcH+fxXQGBkIVMi8N0+EYISAKI452DzjcP+J4OGR/b4/h4TGLRUHcajPodxiOpuzuHSLMCv12anNWONFYCeGs4M7pXViHPmWkFXsbYqwXw2pxtKlPs5OtNjLgjfJPpCHNpgWVlU2hjkh06oHKfVdUJNczRB/x5flV7XPrPQtOQbWonNLqCD4HnhVxEO4vF1EjaWbdasiMxoFeddTULNwDrcbu29e8EMdshX+vBvj6laPmsdU1QKX/pfrWMsLjtZ/iHxytcSX6B/yNv/b/IewVTKaCIFCEWtPtAYUlQFsphErSGmjMrESMYToJWFuTzIdz0tBACMfjnNWeJBKa+cl9iuTXefWVLTqtS7z9XUlZBhWj9Ab4umZ1G1YkTVARNKt+W2a9tlE9WJcUayPktI0Yh7XKZmmhO10aKif391ayxtfOf/kh59ry2FI7Pqx+otFYgkerAioANjWzAn/PhvOHMeQlHI1m/PbvfoPf/q3f5xvf+CZFPmE2GwGaMGqztnWGsxevcOn5q1y+cp5OJ6bX6dFKUspswY1bt7nw3AXGozHHxyekrZTVtVU63TZCSO7euU9RZuzfu818OCZsJahQsZjNCMIQLRVnzp2nFIK1M2eQQlCanPPPP8N0PCIJJLc++ZjpyRFJkrJ9/iIXLpyjKAqOjw6598nHTCcTwjhhsL6OigJmkymT8ZgkSRgeHfPB997i0nPPkSYp42DE+PiI4fEJK/0+02wOUrB/eECZd1lZXbW7Rsg6YQ3Q2JHi1IpHk7k+qGKoT6p7qAKJJxFxgSp3hAdLb1PwASJeTPWGmQYrrLIfuDaTbmLKJYlXVOQCaESf2XO8sc3u5uDZricnNZQ0mWgzMste7rxuaBiYTelyF9QuYzXYmuWOXQJ/U4ezN76uzhGW9fphktPjH3/QYm/4r/nSa/+U6cJwMYJIGcbzElMKyhm0kpjjYUaSGIQWrG8p9ndKxkeQLWYY3SZqhZT3croJtFTG/o5ic73HYjbnqPwe/Y0Tzq3u0fmZV/nmNyIWWYRo5KCoMrk1GthK+35BopEAyPcPVd8Zp0s3CPKTjHn7Pt32ZYJJsrzaQUPqE1W/6NKGwwdRTJEXrAabbKxsPHLoPTZD2rJcVH/8THPUTwB3XSN4C78qC6BA8HtvXOM7737C7s5dovV1Xv/5r2G04WBvjygMSbst4jhga2ud3qDHfDpBUVIsFixaqc12FsDR3V1GowkgCRSgc4TOmU7mfHLtfSbjGUJqolaICgXT8TF7d+6Sdrt0eivMRiN0EHLu/DlanZhWFDCfzpgNT/jg7e9z/+Z12p0OvQsDXnz5ZaSUlGXG8OSYg/t3mUwmbJ6/xOrZLVbPbjIdjjg5OiKfZ7S7XW5+9BGmtEaYoiiYTSZMxxOm0xlJegapAjpJytFwhApjwiCkncYI1Uy8blgscsIwRDrjW7Xx4ZKbjBOqmgPUneM8qNxcFcuT+Akq0m1dA6oymiG8V80pUdL7A7pp7idcpQKoJDGxdKzWG7rgHxoJbIRmyYXJo7FnYd6LxhiMtATDG5eFqPvJs/FKzykagF3xuYrq1ZZ2/z6mkYuWWtbxi4KtC1XbWKNgwMc3zvLxje8xePWfMzMDvvfRLqXSlBIWE0Eaw1pfMFca2ob5BERo2Ns3dDci9nZzZjPD0f6YbkfRTSU3P5BcPV8SFwJuGFZW+4hxiNpuU2xrusU7fPG1i3zjjQ2b0EoImjF6zaxjlarBlWaiIeH+Ni5KsI4ZECSLNXJzzFH4LudWf4riuKTUpW+E6n5+oTZaM/rwHjwTs739Mvf/4T/lxmHCTz136ZFj7zFFpC2r+6V4MGrM9/0PNHz54gaTZ79Fafj9b3/I1//4PTbPrnCpfZ47d+9SaMNiMefspYsopYhixZXL50liRaQUYRAwm89RUjAajQA43D9k5849tDYcHB7SWxtw5swZkjhmni1ASLLFgm6vy/HhIfPZlOO9HYpsQpHHzOZzDg8PWNvaZjGfsbExgLIgyzMW8xmT8QhjDEVZsFjMGQx6rK6scGt0y+qV8wX5fIIQ0Or22d7aYDQ84ca1a4yOTpjNDTKIuHfnNt3BgDBNIMDurEFBURRgDEoquv0Bk9mcTjuwkWYycCuzwWjBNNOU2ZT1ICBxuzPrajI6vWRDovAZMl0XWEOdsamjETZS7VMMtT+2RQu/k7QBr8OlZqRLPkSVPC7wG0VCTR6rHXUd82/IFoAD2dM6RqfKsAa2ppbXA7VrWPeQ5eP+dqbWDFCrAHzUpzEPssCl7Tj9O1GDkbsTni36u2vHqoWAhV7je9+5wdtv/GP+3i9vcfFcCnKX63cisjInm0K/A6U0TBYFaRvmBjolLEaGtJ2ztqE4zkvSNcP0umZ+oAiF4d2vS157uUURlZj3FSocUB6EpLsRer1DmA+40hV8dFy7htWJbryax6rBTpFa+1YN1wWBbDYxoZIURtDNn0GYe5wkH7B97nOc3JuhC91I2WAIhaJFwPxoyMnqHuurZ/jg5lv8t//i23RiSTG+x998xNj7keh0gQZb+GGuqT96IDCiRAu4vTfl99+8QW89JMsy7t67zvDwmNmsYP3MFlGouHBum3YnIYlCYrfVzXA4ZLGYcXg4YTweMZvNGJ+MGA1PSNMWk+EQpSSLlRWm0yndXodLly4gjKFczFEYrr33DvPxkMJIOv1VuivrdAd9jDB02ylKQGk0Os9Jo5goimi1WsznU2aTMbPJiDDcotNp026nhEnM7M6YyckQrUGGIecunCUMBJ98+AnFzi4mbTEcDgnzgqsvXaIscgKl6XZSssWU4+EJaM1gdUAripFSUpRAVuvohuM57374CfNsxhdefp6L22sVGNSsSNTd1fjGHqvdxZf66AkEXa9awGetarojembvZTbPOj3DdAxQG1EFObj/HY412rHZWg09hWl84zWMS/65QjeCcSyke1nam8k8AakzPYMP9PFbWFXPqLwVBPV2OfU13nhXvb7LZ1BrJLxyQ5CP1zCjd9GjAya3f4V9OWHzwg7IfSSwkIaP9wR39gSdLkQSjDJ0JQz6gsVtuzB0OpDsKC693OGdb07odiQb2wauZaSbLdgUyOMAM40odtrIiYBixnPRCocy4IgFmMIterLOWyE8xbOt41rPHbHSol8mfS9JAUEgKfMCIUK6xTmmh7e5n32flc3z6GGEngm6cUwrz5hPxyxKwb3ZITfMNxGHL7CYR1z63AptCiZh/six95h0uj+YvS6d0ViSHnblshpKMJoU/Kt//XvkxQgxTxDM0GXO/bt36HbXuHj5Aqu9Fiu9NoaC6WTGycmEsiyYTEZobQgCRRRFTCYTsmzObDqiyDKy2ZRFFHF8dIRSijPBFkkS0e12uHWwz9HOHcZHB+iiYHX7EoP1beJ2CyMEg0GXIBDoIufk6JCTo0P2dnaRUpKVBbrI0WXBaHjCwcE+WhdcuHCOja1Ndj++znw8ZjgcoYKItJ1y5sI5ikJjypLjw2OkiukMurQ6HdbWVomVIgyl3R2iLNFSssgyjArQoqTdajHPcoyxjPXXf/N3+fv/r39EkqT8lb/yF/mv/sd/o9oO5oE2N/WP75fTZ4pHHH8SSuXi5dibBR4nqlYuQV7qF7W3TBXBJBCi3mC1NtLwgEO+1yfWygmvylhmk7VZy9S5sKHBeGkwabNk4PLn+QxXHnC9a5OH+ipbWXWZrvyGfS2orvedbyqyL4A7731MPtshTltM71/i/tERu7de4tkv/BFJb46KDWECsxHkC4HWkjDQDLVgnIGaSEwmaAlJT2uiWUG00uHoRNKZ5SgBo0lCMusSLFpMRprOokAVfVpiQj6+y1dbF/lOa5N74j7G2JwKNmmPN29WtNS1uleV1Hr2OsDCIFDMs4I//J3f5LlnXmHj/HkSeR49yTicntBrC85vpxzcm3EnF5gggRBYbXHz6wfk999g6+xZfv6nf5rhcMR4Pnzk2HuMwRFNmuqOn7Kw1Xuk8UAk2oPFiTla8Gu/9QZ3jg7ZPrfKycmQ+WzK0c4h2Tzn6hcuY7IpQgcIYjK3r9rB4THD4QlCGKI4IAoDgkDSaiUUWYfhyTHZbIZUAqEkk/EEpRS6KFjf3CRMQorFnLsfvc98kXPmyoucuXiFVn9AksaUZUZ/0CUvFhyfzNnb2eHk8IgyzxCAkorWyjpr29skrTZlntvVNZRcfvZZPnrrTcYn+0xPjtGFIYpSOu0W2SJjdHLMbD5HRoL1zW0uXrzAYKVLEkVEQcTw5AQB9PoDlAwIgpAoVESBoJO2OTgeUZaG1dU10rTD1vYan3/1RZQXL13D23nu95GzQSEVcLgfjRVFtYvsqUTXJ6zUjgoNdYIzfpkKlZxetuGDWUUjVaAsaqbsTeX4e7v7GG/0sfcy0sFABaaVd24FxJ69CtPQs9LkJ2JJteCBeclnvTK01fX2XNaI0t7bBU34/BoWXQ3eTcwDuxfWNYr50T7FYsy5jTMcHoz53GrKvfcvMooPMduf0N8Y0Y5h0DOMDgR6ZuhtGkYngnkJWWDQuWY2TRgVkrFRaBlyWG5zGYWe54gy5qSMSFRAoEPm0xItp4h2iAk6tCYHfDHXvN/vc41j2z7GB5fURq7KYImHXt0Y875dXSJ6ITnzzFX+5a/+E7pBDxUHhJcFul3y0y9cQKtz5MUVEHb/tkSmTPduwKTF9cmMNDmhi8SEC175/OuPHHuPL+GNaK7fNWN64NzmwIeqcx9yU8Bw+/4Jv/MH32JlYxUlJHs7OxRlTtqJ+U//9v+I9a11DvcPuXvvDovFDIPdXWE+nzOfLwhCiZAwm06JwpAwDAkju/ttURTEcYTWBTrPONjd4eTwkOloxPHREXc+fpf5ImPz7BXWz1/kyovP0+51yeczyiKj2+2gAml3cihLTk5OKIsCIwRpu03aSml3O4xHYzrtlCSJicKQrQtn6a6vM75+h707t9m9f5+1tR6ttE2SpsTtFptntxgOZ0RJQqvTY3V1hSgIiIKQPC84Ojomjlus9nruvRRxIGlFgtZ6n6woWP/5L/K1L75Ep53S66TgggKkEdXOHH7/LV8aRMzl0BXV5NZaPDwM/gkoAsvuKmND5WJkWB6CDsyo2V4l8os64YmhVjtUm6wKU4N29eBaZVEH6HgnNLBb0Zg6AU0FHDT6pQbEitD5ulY1NA13Kc+fPQNsMGt3j2pfOK9kcAxZUzNgz8qDXNEVBdNuj+noY9TgKhfEgvKtc8y/s6Dz5T3K/hyZZER7XaKNKcWiRMuA3sqc27cDdFszywv6Zo18PyCchhRG8Vsf9fmLHQimBiVK5hJEoRGEULbQBMQpLOYFmRa8bDTZoMMtM0aLEuGCuKuWcuHejTfDA7QRdXpNXH9cufQsvS88S/Fexnj3iNGtMZe/nHLxxVe5fftD1sVVhNFEQUJX9Hjl8udJwy3eeu/3uHf7HZ7/ouH82k85FcfDy2PX6VYDYont1n9XzeOZQ3Xe8l0MkOeG/+6//30KYUgSyc3r161P7Lmz/JmvfZkz66tkRU6Z5dy6XXL77j3arZTFPLebVmJQUqKkZF4ULOZzgiCg2+2SJAmjo2MQEqkEh3u76CJndHzIR6VmMhpT5CWbl57n/HMvMFhZp5W26CQxJg5I04QoDjg8OiRbLFgsFrTabQDyxdRtrx7T7fXJs4zpbIpSEq01SRzR6vaR0S7ZdMLBzg7D89tEkf1+sLpC2m6hohPanS5hGNPvD5DGECjF5tYWRVHSbnWwG4EqgkARhIF9H2FIw4AkVKx0IsD6NWsE0ouVBu8iig9drXZCaDIqrxkzFnCfRCMaOC4kmywVl/S/Dvus2SvVpGx6MTRZhHefk43x7NmoJyFNSiFq2b/WOjq/2Sr9aU1rq0f6Y82YQH+tPU83VBBWdDbabxHuYwkdBLmON9U9rJFNe/cqYceHRlQbeApj2OiEHLnv7sqAT4Z3eCFJWA8LinGf6NsxZVujVYacr7MnNdHVXTobc+azE7KsoBjnhMLALCAaZyyyPQ5251y/p7g/XfD3vnCOdDbH6JBQKVAKNS9RwRbZcEaU5EzLCe+OIi6FqxTtgnssGn3jSmX4tOzXRwcuyQ8NTxGB5PXLL/PNb/4WLTmjvxLwc3/pNfYne7YdgV5nnVh30UXBjVv3WcwyzicJzz3/K+RMqSL/HlEeO+guDc1Gewio9j/7LGoFMLx/7TZvfv9d+hsDJtMx+/v32dza5M//2a9xdmOAKQ1FltFOY86fP8d0OmM6GRO0I46OhwRhSBhEHO0fMJtPkUrSbrcRrZD5bE62mBN1O8StFmEYMzk5YTGdMp1O2b54kSDucvXFF1g7s4U0hu2tNVrtGLA+sJPJmEAqpJCsbW3S6kwpsozJWFHmGXEco5Tk5PiY3koHoSwrVmHA1eeeY/fGXbr9LqOTA8ajEe1Oi8UiJwgj4iSl2xtwfDRiNpsTqYReu4XA0GtppFSkaUqaJBhjiKUkErIyQNp8CcsM1nrciGqTSTQEos7BIIVGG0HpBqTdH825GDnWpTH1LsFPUBHCOxtZ8V/gtvV2sKkbulPwxKFBK70k7hcqvGqiAdr+Dh6A/aVN4PSRUU7UXwpGER6c7YOa4b84sdkAQrvvjT6lwquB1IOqzz5mwVs3GKCu9b9uMSgbagW7p5hBkHH+TIvknQPm7cv8q2zMKOrzph7yUhQi22ukJkfMY0opOUoS5uUB4laffKckzBJWe4asoyENyIsFB1rTjRLObrSZ3g94dzTl//a9Q/4X59sE0lCaCKVDEIpimgMKoQ0r7ZyMjPd3Si72WxTrIXvYcDK/oDQjCJd7xYNwDbz2tUue37zE4K/9AidHH7Hy+grd1RVu3H+PLXWVlfQSg6TDrRu3ONg/4GjvA1Qw5vLrnyeIu9zf+4j54og46j9y7P0IvBeag4CKMYjGtz+oGEAXgn/2z36NolwQRnDn7l22tjb5a3/5L3LhzCYBJXNdMFvMyLKMMAhYW1uj1+0AhsGgy71797h39z4CQakNMlC0uz067Q6hChkeD9nu9VgZDAiUYtrtkHTarG1s0Bv0KbKSwdoKYRzRShOEhPl8gS5LxpMJRZ6jlMIYQxiGmFYKaUKchghtyPIMFVpVxtHhEWEYEgQBoZRM51OiNCHtdYnimCLPmIxHTKYTiqLgzJltVgZ9nr0aUxYl89mctcEAhWE2m9FqpyRJYndaloI4aGwQI2hM+WUu0BQlm196a7mPpPKBkMr5NRqBjXrSoqmNeIKKqH585qkmI/CBDl7311Q71Hpf97dotGvVfo1IpVofYc/XlmV7Pa5FPsuOJNYNb2nPPuE5mY3PrBZMV5ZVIk4mMdYP2D663hzK6nIFhqKWXhxLtuTbApCVdPzG4tqqGYxlyuqs4vn1Fh8ND7gsFboVM1InvJ9OiFsKOQ8pyoKWLogikFFAwD7j/IQkyUnKgvZUgJozac3Jdcp0done3QFfXBU801vnuwcL/t93FvzdcwoZzhGBscnkS43JIie+p2zICOYnHIaSraOU0WDBXOraWUr4kdtYLR3rt29vrBrIYHdBcYvm+sULdD5nKJOM8aSkyCcMkpdYHE64V+xz5/q7LGZ3WT1/lu7G84BEm4L11Qvsn7zBevjFR468HwHoNunsg7JocxV6AILd6BIYbly/y+99/Q944QsvYzBsnTnPL/2Zn+PSmS1iockWOdPpjEWes8gW7O7u0un22NpcIwwkwpQMuglRoDg6GVOeGPorKwRhTJK2OP/MM4ymUwIJeTanvbrCmXNnGI9GTifbYjZdoE1JGkdgSqIoJFsUDIcT5vMZUiqGw2OyLMNv2y6kQChlF4s4IowjkiQhSSPSNCUMQ6aTKWmrTdrt0FlZZX1zCyFhkc0py5IoitjcWGdjtUen06csDaaEosiJ04SEFO237xHQCiOUoMG6HtbyP6DLxPI1wqkiwE5M1QCRJ1GtK52sXo0/IR3ggAVIWY0/z2TBmpxEA/VE9T21SsGV6lbu+mWNmlMnVABgXJt7UGjMCB9Z5Zh2M0esfbZNpV6Z+ip8MfgkNvZAlY6eGopMrUGp6ldijJcDLORqX19KxumQtStnWXn/kAujOW/tTojPrWEGE2R7HzkrCDJYzBTdJKLQGSQQRZJpviDuhcymOaPckLQgY47cC5ClJMcwEBm/eDbinUnEv8ki/noaks2HmHaMCCKINEUhSUtBKTWLecTiZA95ts+5do8b8by5pFT9vSRHGNPob9vWgTDksSCPJmStI4piiMkMJ9N9ImWYHxTkw4/Zv3uLMJ1w9uWXUXHLefkYhEv1mCQtsmL8yLH3I/PTbW5xDlT6Q6ih9uGEyVAaza/+239P0m8RJglp2mF7a4tLZzZIAmsAW+QFUipaSYtOe0GcJEwnUyaTmJVeh27aIlYB+YWzxOkhUkpa7S537t1FCMnW9hlWVvq045jRaMTh8RGz+Yw4juj1OkymE5QsKfOSvZ17BJFkb3cXYxRFqcmzBUIYptMpWmuUUsRJUol7URwhtCGKIlbXVuh0u4RhgDCadprS6XV5/tVX2Dp/kc2tLfJ8ThgF9HpdVgd9zp/ZoN9p0Uo7SBmiS5jPZggEYRyCMeT5gnarSxSHf4IeqhWGtcbL9Z0x1VY9nv1aA9yndtyPddHCbb3uhe+G2quybjuPBsv4oHLzmk0QrU4tHVQqBjuRpTtglr6DimXhoc8xzEqv7heAhjrD65UrpkmDUmNVBpVfqicwFjQdP22I2P75pjq3FKC8D29lb5H2nYWNdNNGYyjBRfEVZOw9e5Hu8YTzwzGHWvM7f/Qx0Zbk4i8k9LZ26ZQzilyymHdIkylZNgIlCVuSnTKjNZCEGg6mAVL1SNKEbJAymc5YjGEDzedXYV8kfC9IeTmbkk+OkCsB2ayDNF1MFpGEKavRhF+/dpPudJ8rwSXa5/qcyIzaT6/RdtQSxOkw9txo5vEOs+SIEAlKYjJJUZ4QZwMm+zvs7Nxk++I67a3n7R10bWrUWoCQxOEVjsbvPXLsPV7Q9YOIOqPPw3x4zfK718Up/g+Pp3zru+/xwsufYzyfsCpKnn/2Iv22ZZyLPGeeZ9YGLOwuuUJKoigijmPKUlMUBePxkHwxY321T6fdYTyZc/H8RfK8ICsWrK30ee7KZaaTKXuHB+zs7mKMIc8zDvf3OTo8soxPBshQkqRt4ih1DHtBq9Wi1W6hNURRRBgGSCWI477dN0trWu2Efr9Lp9tHGI0pC7JFxmBlwOb2Nuvrm3S6HaYzq67o9bpcPH+OjdUV0jhGSoUUISYQhIFCa40UEEcxGEMSBFXi7AeSYTcXvdrr/cEvl3QP/sNDpBBz+oInp9iE4ZIqSbbR7jPVQukZbt1M9j0LMSOghd01Vla5ce23Eh8K5q+tGGW1lDXavgG4D5NG6mtqycX3nXbzqmKzwuOMqwOWfdWCtA+rMA6IauzOxjuozhqBCNDCqhe0sQY4UbkPuucKw6ijCV46z+YHn/DFUcGdC5f47ltv0jbnSf/sJtng+4TRFNkeIkxC3ArReorUBj0NGE+7IBShVkR3P0dvLmlFBbqniTuGe9Oc+6OQpFXwT3aP+KutiC+0VhCLFiYEMsEi10gj6CcDrpzf5p/c/4SfuX2XFV0iLvaw2ces3lxX6iS/wEjXZF6vbVsomg6Yx3MWxRwl4GB8HYDhnYjJzodceuUnCNPUqVtcDmRTmUIRRqNkhOFHHBzx0PKQefsDL3Hs6ne//ib9jW2yfI4pM1YGLZLAIE1JkZfMswXzfMZ8kVNqKIoSKWWl4wQoS402Je00ptXqUgJ3ij1Goyk+FPKFZ67QayWsdTtsb66x0m9zeHzMbDZHCUlv0CfPS0ajMcPjIwKprIfDyQlBFBElA+KkRa/bIwhChDB0OilBIJESRKmJk5A0jVEywJQFpdCUheDs2W16/QGrq2sESjJftJhNp2ysrrO1ukIripBKolSA3/I8CEKOj09QgSIOQlpxQhpEjVDez9YvS/71P/B043IyOEgSPrXjk1X81uu1Jtflv/MqAuHDTJuuVwACmUjyckYUdNwRW3wyFBCVMwFeMez9aB3Y1UERDe+BpqqiQsRmqm7RqE+9bbwvwlhjmveCsIuJM5zhI9xM9Qzj9NlWJ6X4aOff8uyZv1hn8AOnXLARbM1t4Euh2d9ucealc6y8c53Pj94hf/kV9u/eonjvEsMzKTI8Ieq8DatHdtcMGaDLkjgtGO1KVg5+ip5WKJMynw+ZjYasDgSd1JB2F0zKjLuHmjyN+PtHBVG4wusRpGIVnURI2hTTCUXY5VeeeZ37ccR7szs8fzIk2QkItxMb8FJ5EtTKhno5831mdcZxtMJY3iYvpmQLSVkcEAcDklaf7S8+i5GhdZ304E1R3drepUSYgH763CPH3uMHXWMQsiG5NL76wXNVMJ4s+PXf+Dqr5zc4OTxk0B+wsb5GuxWCKcnLHKGEdb8yJcPRiNmioJXGZIsF85lhYTRlFBKFEWWpKXWJVCFRGGJ0ye7ePs9cOU+33aKdxkRxRJZlPPfMFWbzOVlWcnh4zCTPmcwWTCYzbt28xfDkkPliisEazqIoIopCgjAgjkN6nQ6tVgJogkDSbSUARFGIznOKPKcsAsqi5MzmBoOVVVqtFtpoOu2ErNWi2+7QTltEUUStv/MbQhrSJEaqgCSM6Max3Z69nrkPbeWlHTnc70pIWtLlekd9lgIlvI7ydGTPk1QqsDElCKtoqF/QQVK1A2xtAUcYpGgx0iNCOlVkWxX6W9HSGtrs/w/ZTty5d9Ws1H72br4gEabecW9Z54tTpvv7+pwDXo1QiyLCMz27E6VzExSUwqDcYhCqAeP8Ojvjt9juvFrpKev7N5Qi/tWE5OBLz7C9t8OFj3dI73yTb599mShbcHgzwRQxw/sv8OqXW0zkNVqJIs9CZqMUWUj0ccYEzXqqbb4CmTLeGzLpQX8DVjpzopU5O0ddht0V/lWhiUSLl+MVGA9J9XXM0W0Ua6gw4z85+zz/5304Sqaom/uc65+D1Iec1Gy03jvOvlWgFOv9dQarz3Nz9gllPkGXiuPR+0RBiJaa1a1zmNway+pwRYPVfyugBKPcOCgJ5Y94N2BfrBHA7ZWG+YzzsnmS4drHt/ngww+4YMbs3P4YVMyLLz7DdDoh73Qdu9AYrZES0nZK2o2YzeacHB+TZwvarYQszzA6ZJEVaJGRtmM63S5ZfhulJL1u2wJmEJHlBVIpeu027U4HjKTXG3A8HHE0HDOf3ieOUwZrG2idMToZksYJaZpY41igaKcx6yt9kjhGSkGShKRRaKeoEOTZnMlkQhgEhGFEGEZ0Oh2iKAKsnjoJYlppilQBQigb59/IFaocmw+kopMmFnBdEy4ZRj5jWbLIN66v3ebd5KfeSeKHfcaPT3Esh3qc+tQvNcurWwC8eC8RIqYMdhtGNFPdo+lnaxrXLakTHOP0Envl+oVXw3l26lUgNSO2GOmB3NTuucJUAE2DRTvZxJ20vLAaFxJhF9CIQbzJzujbtOI+aXDBRR02WLOgYbyz4yBrxez+yk+z+S9/m+5wSjD8mN3jdxAbV9htbxP31jBHa7SLAePxEVJrWkmfPC8g1gi9YJRltClpY+gmKaPxlN2hILkc0Vqdce7iEb05nIxjflOlrMxmXJ5eBwFRp4tUHfTwBu0s42+uX+T/ebRDxgHqnUPOvL5WE4lGvwghacUJm2uXWOufY14U7Ozf5K75XXKhOT7aQZYFffMCgUiJ4gCdObUMfjES+J2BbZ8W1e4en2ZefsxM14svf5JiNz78+u9/l/WNVUxZIAUMD/d4+9vf4erFMxRFDthUh14007oky6bkeY5SArRiNpuRxjGT+ZzJbEY3iijyAmOg1WqhVEAcxYRhSKvVptAlSikQhsC5RfVVSBgGtFptJuMZO3u7xCqhLAOMHtLudFhZWSGOYzbW1ul2UnrtDmkYowKBlBCFoTVKGMPC7fBgvQ4MaWpdvgROOV9qpBJIaVMz+ggm4YwmSkmrOjGGVhQSBfX+BL7F/zTcs5lf90FkXb5zLbA+OcUIkEZjhPJHgEZggZfMPIAJn+zHYFDE0lDqnEBG1NBrHKh6tknFZB22OgJqMG4bd6orG1nKTG38qnLcNrwZ7L20+6CdJqLufV3pKR1LrhZhu6hoqJ7h6ymlYGvlp9m5/8+4N/wmV1ZaQB8Pz/56G8Ulq/fRwKwT0/ra68S/8zZbKuRKd4XZ4oBv7Ay5sfk8pQxJojaqGFGYgtlwn07SYjEzlFHIwgimZc5ELxhITS8J6ZuIg3sltw6he1Gyed6Q9k7YH3X4d0XEfyY3aBW7LDII4wgMBPMFV/uavzQ4y68mCTevf0Lr9ojehTZenSCFpN9ZYWv9Mq14ldHJEfeuv8fh/nXGbUOxOmQ6HmMWIy7Gv0hkVjGLEpPpJUNm5dvr2twY7+yusCoGP64eLI8FdH2HQEMP5b/wIk/TciZOX20n/Wiy4Nr12yTtmNHwgNl4jKJkNp1QasN8kdmQy8ppH3ycuBSG6XSMLksCJdHETOcLZvOMTl8gpKQo58RJzGDQZ3VlQBKnSGX1o8a9hFBugkroyA5RVPLcs1fZ3Nrk2kcfc3B4wAGC6WTK1nZIK0npd9us9nqkcUyoAlQgkdWWAdgUjwiSJLW+gca4wI0A3ECOwsi+k6jZq/1lUEoRBAFKCKIgIFY1UDyoy20cMMsTt9FbDzmO06k3DTx1OKU5baR7AkuVjaARCCHcJmnVqBXVxkd4XbpA0DUtJpwQskkFsE2QBOeKVRvQ7AjV9eYvpuqS6pgFMrf5jPBQYVVJwoF1re5oihreEaypz63TnttrTX2Jy+eLAS000kAan6Eddphm9zkcfpOV/i+4d7a5NqQxVUBJc6E1GA4ubbL2E5eJvn8HNZyx1Q74j0PNB/vf5V7rC5wEKTIMKMZ2Z5WDoyGdNARato4yYaI1C5GT5YaugI0opCvb3Lme8+Fhxsb5FTb6XfYPSn47KvmVvE8cHVMWNmQ41yXR9Igvxau8u3/IW9029z7ap7vdIoxDVnobbG1eQRFTTEfsHl7j/r3r3L99g/v3r3P2F89Q5oLF9Jjz0VeJWLHv5xdLr4+nrFUMzbngdeqioY56SHnM6oU6o1G1Vj5krj5wyBkRPvzkLiKCuBUjVQ+dzRgeH3L//n2Oj064cvYMSRgxLzKUUjYwQWvyLKMoCvJsgZSK0XhCEMVkRYk2EEcJYRShRxMGgx6DXoetzXWSOCGOwqpGdmsWgxbOIV0FgGR10CeNI6QpyS6d5cXnnmU0GtHtdmm3W2yurdJOYgK3INQLjG54DQibmEaFCAFFWVIWpT1XCMIoZJFl1oIscHRFooQgVIIgECQqJKioz8MA9+FtfPo0U51hTh0X9QR2RwyS0vi38fvEPnkAXOWZrTfScWoZgXZ+sZWngL2idisTIOQaU32LjtjEJrTRFWD6LdorN1Dq+H7PYZtqBSOEc7/zTNcBr6mSOFZ3qe9TOSpVPed9af1f1a4Y/h2q53uWXFYLjgGUkZztfon3D/4tu9xGJu/Qj16p4PX06Kji45z70eGrl1kfTYk+3iUnZO3cWV7ev8Pmvbd4L1plp71CHsUUWUYnSRnOZoj5IavdHkJEZKrFSEIuc0pZUCLpCMGVtM9BHnD7u3O6mwYVx9xYTbkxvc5Fs0YcSERpCJgyzwISdZ+/sdrlrT/+I4ZrbU52cr76Cz+L1Irp4S5H+zuMxyfcvv0BRTGhtbbClbOvkbdOmIz3OBt8nph1C6ZGV31oP+jqd9WsWC8RO4Z8zoX/gGHAPh+9wSW+/oylNJCbgN6gjTZTpEjob64hAzDakC8WLOYLQqmqQIT5bOZcw8YcHx+T5zkyiCm0YTKbs8gyAhVQliWTyRxdGlpxxLmtTVb6PdIkJA4CKkd4xzS1LjHGUBjH0AWgIy6cO8N0MWcxyMmyjDRNicOQMFBEYVCHcILVOxsL5FmWMRyNaKctOmstABZZRpZlgFU7RJFlukbbd8PgANcmuYkDVU+ExnM+c1L4qoiHTChfmoDrjpjay1Nj0MaqgZ489UJzMXR6U6EAUfkfN3dvqNkw7uUDSjOnICMwAQ1TJD6/LlVLCWrY8uoC2Ty78kjwWd48KNtTXEIcp5LwwE614NUZyewx43ivWXqqcMuoVz74BceyM3tGr/0c7P4Ow8WIYPgd0hVBHD6P1gojNbEImBXeYm8wosQFUVMqycFPv8j5eUF5f0hxdEiv1AStlDTIuHv0IZ8EK+wIKGVMJ47IS8P+cAQSummfPEnJdcDcFGy2FHkQkBrBRhrSayfslzmZANNK+Wh9QHTvPhGGVnvDBitNj9nTkvODbf5Xr7/G//Y7f8xbb39Mf3CWTrHLweiAo5N9Sjlh5exF2oNnQCq++40PufXWPV7cbJE+t+VUehq/JX0lQRiXZ++USGjX8Notjx+1eqGqC/UkrWPUH35eQwmBEJCX8MmtO9bVShqiKOTkeIEUgnTQQ4YBaZpa30qn71RBQOn0sXme2x10Q+3SO2ryLGdlYJOTh1FCmsSsDrqs9rt0WilJGFbGKAEYpWyDygCDITAQSE2hFZGU5GWJlFbEL+OYOI4JlHLvqiudK0BZGkpdUuQF09mMyXhCp9VCCK8aMZalF7kF5jwDBFEcE6iAUAUkQUAUhkRKVbtz+FI7fNf/PlrEqd3la6L8qLNFbUAxvj+F82hwnfWEAS6AD6m1bSGo86xWsEbtZ+t3qfQ+uPa8WCVMyzFdMaBKz2hq0bt5j8rqT3Nh9CKKRghFzVp9XUz9PLdo4xmyC112HNs9xbOwajP4hhxS0x/TON8b5rRjb0oozvRf4sP9b5PKEQejP+LS6m0OdZfRaMSZwZ+tckVo9zyvI0ZIiijg7tdeZvPffZvpzgHTbELZTog6q7wclmyWu9xWMZ+UEceyg1QpSRwxzTLm5YxsOCWKu6TtDrtFwFRAr9smKXIGSciZKGGsZ8x1RDEcc6s8QRQlg6xEqS0mWUEETMd7XFnZ4O9eucB/sz/h3/37P+DqVkZnXbBy6Sxhq4tQlpkWuWJ/X/PeH73DV//LX8QYiU30fsqoWhGoWrSspRD8ytlgQg8vP4IsY58m2NaldnyxP8NxQWk07XbK/n5Bls8IAsU8y8gWU/YPD8mKkjBSDtwkKggRQhKGIb1ej9F4wnA0RmtYzEta7ZjxZEzabtHrpKx0u6yvDuh2WrSikKDJZvBzq56MCgidq1YRKLKyJAgs+/SbPlpXrprV2ltY4NLGsMgzirJwrm/rRIGiKAxxGBAFirIsKbRmMptSlppet0caxaRhRCsObPy5ofIzbRbx4KGlFq9E5VMvKXQ1/V20ac3BTHUPUfmY+qxTFcQv7cj4ZBQjdGOTHJajJRscVDRA1n/2kNySKxzrIV3Ts/eo+hsLwrKeqF615rnm6RSmtbAOlWduJcE0dwY2S2qKJR4rfB3txPfX1FhtquTkTa2s1yGXjgVv9V7lndtvMgpKEq25M/qIiTb01M+gdSOdj/ALSW1EBEOeRuz8uZ9k67e+SXAvQ81zCCdkSYe1WBMXBSvjO9xTHT5RA4bBClEQEsYJC10wN3P2DuYM1tYoVI/ZBDY3zpKhaYuSQGmCw7ski5xcdDD6hOH0Hl2RUWrDraMZfdNGdFpcvHCRvxTc49dPRtwdtvjpL14hVPWGYiaXvPm77/DNf/+b/PW/+SW6Z89ilWaGOuih6fvs3rfpElhRlrpXEOUjx97j25jSD9Tq6KMB93QpDNzbHzIZj1DKGpyUkkgkcaQ4PDxiNrN5FpI4Qhtc6kZJHLfQzMjLkqIsieOYPLeKb6Ui4jikk8Rs9PvW3zeJaMURkZL1/lWwPAtZBlAlBEpCGEiiQFKEmiy3inxtNJR+vlh9l5TS5aK1RrA0TcEIoihCGMuWwzBESokUVrfYarU4ODwkTUKSKCBxgFuJvqda19axXrQ+tcVPY6R4UGdndc+nxJPGCu6lbmsI/EE9+uNX7O4Qp1rQGOotG5w0UA1mN7n8giQEgU4oxD4lJdIEjTFjVz//jIqlNvRB9fTVLqOZqdtZVPhV8dVa1eN1qLVx2p8jqolf73mmTQOyhX9N7bwQasgurYIAYwRB2KWTdCmCE2bZgqwwmEJx/sxz1aJc77XmXqoxX4yBIgm590tfYv1b79F55yP0eIYJW4SRZNCN6UjDYDRmkO9yx2TstzYYkxIFMYFIUDJjPj8mNyVqfZu9wxHdOGShc8TshI2VPicr6yTX3yYbZeSyB5MFSpX0oi6f3Nqh09vgfrnCYHCBP9e+yx+MFrz7xh1e+cnzCGEoF3B4/y733/n3fPUnz3H55WeQQVD5Jxs/TvAqBfueTRuHHUum8tO2w0PyKbPvRxiR9mnF18/1W65h72jIdDLi8HCP2WxKFMXIQBGImP5gwN7uHifDIZ1W6hLMCIyGvCgYTycUuiRttQiChNlsAQjW1zYYdFPOba6zvrpCO45Io5BEBY3B7Q0mDdGdUxjsvlKACOyGl1EQsCgLcl1SFJaxetC1obqCIAhsFrAgxBtpyqKsWLI3BEohaacpan2NOAyJgoBAWsD1Aqs+VZfl5mwc/EEEtDrVTZ4GgpqHnUadREcASIF59KL+Y1yWCYF9P+lYphX1l9+/MdH8AixtwvsZM9rG5k72Hgt2CNWM2Xuh2O3arfjq9X92oZRYVyPhdjGwi55PhlOzLQ+eGuHyK9i3abBf48G59mbwGceMMwxJz4gx+C3bG4I0a4NN7kxPGC00aSAITAslk0p/78+tF2TjFrH62WUYsPflV5gNWrTf+j7s7aEHPVpCEkYxq/GCVqbYFjPu736fvWiN/fWrnLQGhGmb6WKKETA/3ke1BsyFIM0mtKKARV5QiJJ06woDUo6LKVlp2JQGJSNWVi7wO29e42uf/ypvThYk7U2+crbkg/KE2x/dY3WzTxiUnItjfvav/Vk62+dcv/jUpX6JqxRpVKuhlyLcWlNL86Lhu/0fUL3wWYugFo2nk5zd/T1yPSdOErQuSZKQQMXs7w3pdLusrq3R7fVRUiFVQLnImC0WTKZTptMZWkOWl2isv+7WxiYXtrfodVNW+h3i2PrdRkFQxdoj/JD77KKyr3OoBIG02e/LwKCNtjkftKZ0GcCMDvDO5tYhXdot0p3BLstzDIZYhQggcVuph1KhGghgJ+9yedi6+si19rQo7RM9CwsK2qkQqgneWBSlZ1pI5zz/6QPsx7cY15B1Swo8a/cKBJy9QNdJaYQzRekxO9l9tIJpMKaVtZ0/rDNQGVMlBvNAKitjm9cRN1QYuMQ17jrvAyuhBsQQdGkQ2i+9pn4Pp/et4cGngLS8t1YIG5qeyTQA1+K8W37CkFYIRSFoRQnk7QbfrhegemgI625X6fidKkrA6KVnyda7rP/OH6HHhxCAHCToJKQVaCKlSOWUDTNkPHuPgyPBvk456W4y7W0yB4zOkQWIMIRAosM2i8mY0WzMMAnZFpvcXYw4mE/ZbA1AatbXC77+wUdcef513ji4zX6ouTxQjDoSEUIQRWi5T2frgm13U9aLic/LW40V/066mjO1jbX2JLHjRuKztD2s/NiAri9GwGiW0UojkjRmNp0QBAFBoFgsNCvra4RhSH/QRwpJnhcUZUFeZIxGQ46ODlnkC7KF3Za83+mwvbnJxuoandQq7ZMoIg5CkiiyARRAJTafRqqH4YmoP9QLvdXZhUISSgCJDtwW5tSM1xv9pBDkZclsoZHKgrQQirLMKbRGCo1SgV1UpKwfe0ptU4upP7g0875WopFj9qZiz95IJh4AXLuy1xuGV+5Pjx5fP8bFIVVDP7rk0VAZxAx1msMSoSVGGgQx8dwwVffJWpDJAbGOK9az1EPuo92Lq3TfNHMCuO+NrnZtMK4OWngvBMNoPuWDyTu83v9itQ2Pk81q9oWd+gq/U7F2MFtWTLtePPwC6jpZaNvv+YJesEZ/4xU+vPU9MLn1IadxbmXgoxYDmzlqfb2wvquLjU12f/nnWf3kY4rDGZ28QK1twOiYMtckrRSlDbGAaHFMe3GXyehjjj9MGK1eIvvcC8wmGhVIwnaf2fEh2XRGQE7c7/HBvfv0Ox2OwphxeUxsFBEZ/Y5kf+c6F1cGXD/aZVYGXMpD0tBg5mMWK30qt7DK5mGNlM33rX1CGseqpqh9qv2k+TQnoscWHGHrbqpcnT/4CntWqWG8yCnLHCEF48mYTqdD4TKHtdotJpMJRVEym00pF4KTyQnD8Zij4UmVy1YqydkzZ7h8/jxrK6vOlUsQBSFRENKKbJ6C6ukNsJWV2ICz6jbKkvKzoYIQ9ZFKWBV2/7GqBVStNRaAFJKsKClcGLPVsym0MeS6RAjre9xUqZ5uywpIH6FYfSTbpZ4oBihNrZvVRtj3FjhxySzdSNBM8l0nZHnSis/a5fMaVG3b7N9T+lMjtOtTRT+5RKIHHBT3OFZ7bHN+qf9NpRP3R+11ppqUwgErLj+CPSZPTWzvtNQKUm5NdojDN3m59Xpj3HoFAmhRIis9pMsJTIGNI9OVHruGEA/JurqfUBEb3c+jxQKCDxBSE2ivrzTLE0b4xOrOX8Kd0zC34Vlv1u2x88qr7Beajffe59xUEwcR8zxjXpbIqISkjVg7Q6QixOo6SWeDdaORg3XmWcj7b+8yH0+Q+ZQgCNFCkeUFQTumnxraE82RCimCiKK1Dse7JEJyfABb/VX2J0dcO5ZcDkLaHCPSlo3/EF4K8cBZey5Ug8PUenJRtbpXKVQhLz8Q8B4L6Pr9tWypGdWj6uLFMIlhmhnu7+7brdILQyCU7VclGHQ3yOZzWmnXXmcyZtMZo+GQRVHQSlq0khZJEpEmKSsrK/RaLZIkRkmFknaXhiSJCMMH6VkFJq7aQljtXgVGS4D7qNL013gAIusV0EAgJUoqhKi3zhNyOStSICU+HcsPU8ypxzfZbT22PNI4m7q7qBIajWfB1VyqxFotaoatfmjf4B+DIgzLmxj6yK86p5fFDBeGXTcVPuWoJCBVq6xpxaG8x0ItiMoIv8G7ZTz1hKzHTx2w4D0J/Cef/wq89GHcVjm2li8PXuStg++wlZxnVa5VvNqgLRiYGg7sPZaXxOZTvXubPVdWT/SQoohoqx7zbESiYgfWdapIf55ftKie7DXVTknl9dQGSiEwYcjO515A3log7x5wYkbMB13iV65QIiiVokg6lEGAQKGMzXFw96MDfvPf/PfsT+Ern3+ZV197EVGUzMZD2q0YdXaDZHKLNA/ZOSkpckWwcoZsOmYgjzgY5Wy14WRR8O6dfc4NWvTf3SG6NKDox9RudfrUG7oEOU6aaG5Iatfl2s+Zavl7dPkRqhf81H30BC0x7B6Mmc1mzGYT9vZ26Q76jMcnmNIwGU/QZUm/2+PC2bN00pRcQjCZkqoAKRVxnNBppbRaLZI4Jols1JdSEoEgjkOSMLTDYkncXi51mr6a3Eq/CJ56q6XrTr9frRN44CoBNpJOu3TaphbHBFa9ECjVYBafzmofXupVevk60XDnt9ND412OnFLRuOtE/Z7aMTOfjuUUCX5yituu2xq5apCrzZT1nmGw3INN3gqCVA5o58cMwx1WuVBBrgcpOwRquKu2Rq9AvXTg3wAsoytpQ/pEOsCF9CLX0o/41s4f86UzX2ZVDhBl7YDmQdP+p+u+q4xqVB1mn2nBVhq7gY+HbO9u0UvOsT96m6DTx4a/1r1tXd9kVetK3K6WEfdWDZWJW7IpA8lur0d70eODbEhurnGht0Zt9JPVuM8Xmg+/+zE7Nz/hmQspg9GY+fQW2xdf4d6ORImIla0BZhAxX7uKwLA2z7lzaxfmISYdUOYT2nFOVgb0ggKF4cbxjM1Wh607GelCk2/E9XZ/3vuk0bLWt9IDaz0q/Lvafm7KpQ8vP9J8ugYerutwSFYYzTw3gEYbq6c1ooUBxsMhQgVIpXj++ed5+cUXiclZhCGagFIXBEFEmraIw8DmJlCKUFr9qUQQRyFpbLeyeVip8PEh7dVQEoDxanZ3+ulrHrj/8pfNpUe4NvEg7xXxNqw5qM73uGs+pTM/O/hZ1lUaKqAvjXcv8pjb9CStNVkG4zartC9uAK2bb/RkFLtPX22OqkV9g1TWYOWWWnC7JtRjQ1aAJoxACE1fnmevfJ88mBEVSXWq8EZKBMJopDGUjtE2s4vVvyv6ZAEXq/oB6+ESy5Bz6Rk+Lm7xb6/9c3754p9jPbzopBDP0erINWvw8f3nXdOsDcGfWzNXx62NAGk1ySvtS9w7eJs47ldG4EYrOhuFb6fGW7gh4QG81oeKSmIQccSsyJkXx6y9uFmPMue6J4RidDDmwze+x2g4ZjgakXRafOWVC7zwhS+BDIjTfTorEbIfU4gcYRQG+N7wQ945fptndZeN+Av0eyuYIiMwEp0XdKOMSGlGxrCbhawfaeTomPjiOnlUNNYWX3+shxTLOveHye+eDT+qPBbQlc1+aawGpavI6aTXftAVpWIyW1DqDK1LwjCiLDS6LMkWM1qDFV753Ku8/uqrpJGkLDRBlNDtBTZqK4yQUtp9yYzdnA5pXbHiMCKNApsgp1qp3PPN6Tp/WrHX18akJcmiFiF/AAZ5oBZCoEvjNAq1VVu5XYX97R51S//dQ59xuuZO/+oIbGV99e9T6xmX1x7pKlu6742bF7UW5MkCXKDquKW2FSCMxMiSRTInnsbgPEuqxncBDxY4LBjaCLKAXnmGo/IOm+KqBelKS2uZaxPGPch7Mm2EcbpYVy9nsNSOoToPMoSBy+kV7mbXGc4qTaoDVutlgfcbrYSVhsENHD9tgrRpfAM+WsZgaMUbBCIgibssR2j5AUx1ByFs4FDtlOwbuill1dfooM39/B6L7ojO1nO2/iiQUOaSwzvHfPid72NMjhAlnXbBKz/1OhsXLlp3S6PZ2Fpx47GskMZg+NatN7h9cMQ02uWCKXhGfpVO0ELoguECUhWSyoJuPmEsOtyaSM6mHbL3T0gvdGDgJU7ntrck9brPPgq0YvinQsUfUR4P062sgI1KNDqnOqeyegIGsqwgSgI6nTZZltlMW2XBaDhCCsmrL7/Mz37lp+mmKabMEFIRKEEQRnYbG5cGUbosUUoYwtAm+I6CsAH2D1mdGmPEToS61R5YtXySEGMeaORHEOUHn0eTPbtPnt24JDnWy+Ez3vBRK+updzZmWcsn3UTxeSJK4wXdUw/1IH1qGTD1eHyyStNy2mQ1QkAu0HLCtJORjvrVZLa+1bIhZoKnbQZDLPvI4h5ZNCMuWw6MTQWWXioSDpCNEFZKEPWzq5YXNqdFDdX1mOwGHaQpGHTOkGHdDEu03/uCZcNnw0BWJfLxe6f5d7J38AuwVbnY65QIuLRyiXaQklf3rCeLcIZBD9I2MsgZ3cyycck7PACU+YBP3rxG2JnyzEsX8DIeCCaHC9795ofc//gD2n2FiFK2zm9x5aUvEbT7VsVlCuodnDUQOJC0Y/nLF77IpPw6M53x3ug6ImjzQvvnYC4JA8HdwxPSpM1KBMFiyiJMuV0knI8Djj+ekKwq0ostSrFojJnGWG+qpIRzE6sa/dMn7WN19nmAhXmGZB5eJaUErVZEEAZsbW0SRiGj8Qmj0Yif/Mkv8/Nf+Sr9dogUhVUZSFm5kymlXICB3YI8UpJWEtNNUpIgsBnyH2XhF5ahavGnI20/NPYIL+ay5ErmAfd0VT5NtfCZ6me8KuPRdTaNdqi4iQfl5hWNtfOH0zH/eBRjGvFbwkWOCW8AMqSLVUw+Z9I9rnxXgXqyLemipL2fDFgNXmRc3nWeEe4czzgdqAj3HJ+G1E7ZRlCvmyACy34tA/a/DVob+uEmW4OLjIoxu8WQ37/1azVr9RIJNTAY7ILquar1A16GX29Us/t/1X17rvMF1meZ/d7lg7Z1r7XX9fiQ1SRyHNc3HH5h0fmAm394g5XtkrMvbiCjFJDoMuXOxyP++Nd+n+//0RugDHcPx2xfWuGZ1z+HSrtoXaK1lQyNMdbrx7iFw9jdY7TRvLj+PH/jpb9At9XnxfMX+bnXv8zWMyGH8YK5CBj0u4znY3YWESpMaImSkJy7OgGhuHVzzL3vHmMWbrv3pfzHkmp7p+qzP+7UVp/iR/lYQFebumMr4G04Z/vvq4xVxlYkDKz+rN/v0uv3abUTjCk5c2aLr3z5y6RRZEmGtqKFClSlu0VCqCRpGNJJInrtFq04QXl6uyztLP2cJj268eMFSB/G+zCAMTQFr4c85yHFVyeQAiWsKsEnOBdY8PVRTKL6+fQV4fSrPerJD7tLqQ3NbAS+70pqQ5pwbaWgCoUO1KNJ9o9zET6s0/N+v7mjqc2L7fk6UucsekPXYRoV+Qy1pgJjb/gsi5LDk0Ni02KhRh5vTz3Xiq1+3Al/UiNhjr1nxW/dGKihURjD1eQ5ZvmUUkk+2r9DJ+g1RF+nkmisjB5S/X5ptoO1e2+3YXmlevNQancCXsiYaCRol/7+7n7GJvf0Ok8tmjKUb1dvkHYj2fS4/5191i4H9C8MEFKgS8VimHB0/YR7H3zMtVuHMMr46MNDvvJzr3H1tVctGTCFW5DKagGwgR8lNkGNY+nG1mm7fYb/6Lk/z9ee+3kCGZNxzFH6q+StAtNus7G+gihnHC2gRCKKAiFK9kRIEodc2xlz7Y19inEPYayfsqiMzKcXE6hdA+HB7Znq8nhcxtwKbYTxMqmrXnPlrbqhqrgU0G2nxKFg2u9x5swWmJJ+u0MShRitKR1T8PlzBaCkIFKKJIwIZK1/q+7dEAsehg/m1PGmb/GDk+ZBZmdO3fhR19bf19onJXB6Ztd2xum1GoSybqPPWJpMdsnaLKrx0TjB/vIiISyJxNJ3lBSValM7OdF7MgThE4m6DvCcIciJ+AKBXiwQcYBBkU5XmQ4OyVfnBCctFvEJhDHRLPLModIbzGVClsQkChbmkJg2VNZ9avWBZSEVaFd7mDn/Wns7U6lGhfdqQVcpH1eDFQZ5l810CxMfcanzqmc3eD9T03hWLegbzJJxzRZTxXLLqg7+3yIIuLXa4vlM8G5inEdGbTirs5U1zZIPzgJdJuy9eUzQH9I527PBQPOURHSYjncwMuDbb1/j5PCI1bWU/+Rv/Qyr5886wqOpQ+DdhDZ2i3ghXBi/yynRnPD9eBUhSrQpOBnvMrsz5ePFv+HZzV9Cxqu045TZcMiNwwnbqx0SBKbdZbQY0+62ef/+MVrusXV5g/7GCCMLC+017XVuerVZ1uLvjzgiTTv94KfBRe083aiMFLQjRWACttZWCZVkY3WFQbdLGkeAqaKzVGDTLkopSYOANFQ0/QV/GIz605bGuvInuFYQKMWiyDFaV9FddsKYyqPBM+A/aTGP+Aw0JowtPjm5wJGfB1QdTfHRf3rCgNepTJpZ1TzwyjBgXh5wJI5pxWuEWcq0NaS1ojFlyVycsAhAlQEUYEqDNBELc0wQSEazBWkS0+2UjEe1SsGllEE0dMIWO4TbLNLWw3od2LoIt6I3DWk+2PS55ApTccJakBEHHSrLphNTvPa2AkaopChtakbruXtzM3LtnucNvoWSXC/GnDEt7njPDf8CeN2uqOrt8d8XrVP2v7egEDtsPbNBGq9TTCLMfMTR+B6zWYYoDygK+OrrHZ778k/SP3fG5ZI2VsQ3Gl0FMQv3v3K2Gqfi8BILEk3JIh9x//AG9/ZvUCwKonSV9U7J+bNTFuYMRwcRYRDST9vc3t9jTUVkxdjmeYgjVjZX2VkIzN6C1bUOWh4vgWtF4KuX9eqjRyPCY4tIq0TSylDgmBaV40rFGn0oqjAQSNChopOkhKuKtZUVQqWQwg0EA0GgKjEtVIo4stS/qY99GKjz0CPu+Ckm/MB5ohrL1d+nB9YPC7zeTUxKp4T3SW/wCgX7IN+ej3rAA3poc6rLK9Zsmn/WL+KJg2NEpTaUfpZjma80csljAyxDryfrk1Zc4If2IiP1IJCKhE1WdMQ422NUzNBzyUTdJ4p6iCBAuIQupcgwam7Hm14Qa0GZTInLgPb165QrX2Uqm5PUYFxyG0yt2rJKAS+223nhg49tCp6arfocCQkRs/GCNhp0iRB2HPm8DXau+RBXgRSm6mPfi5p6YcfXi+ohtp0cm59EMZvHC5J2wDyy7+Hj5Rq1s3c3loFKJFo9w2K/4ODw93jta1eJg1Vi2szVmDv3dphMDugOBPH6CqmEi89s0z9zDq39zrvOZ9e490PgfcklgsPxfYo5rK72CIMOmoLRfJeP777Hwc4tWnFC2OnT7nbIygNePffzBNEKLTGkFaaMFy0m04gglkR6wuUrHYxYMJvMKHWCISZUc3K1oOo04/W8finzo8rX8UfMdCsMqKz7rmqNYIQq8YsP63CTQErchoyCKFAEwu4FVhY5Stn0h2WpUUjiMKQVBQ0XnPoZp2ryqUTsYVuSV5c1UFj7ufmwl/1TED0pQLhsXUVhiCOrKPWqMGvc8rbdR9DqRsUMTgWAd9muNX2+6IZOykOxT08nhXT+pO7GhqXrlwz3NIfck1bquC04JbEISNUKCQMKM2G62OeovM5I3iaN2sTZglmckhUZulhgAFVqUtOhJbcJ1DoHScT524fcvrBK0bR2u4fo6phXIfjvHNvEZgPzqgBpas7qBcmV6AxMM4SsRerSGGaHU1przoPCuZD5a7TRVRL8pqrPqySoQNgzEf9bcLMreOHI8O56Ha1YSzoGlQtMOUMnLUTwEq32NjduT7h//2Ne/uLryDxiPl+wP7zJOLvBqNhn++o2gWxx953rvPjSgP5gC1Mx1iZRq5UkHuxOshN+45u/TjGf02612Ny8yGhyQrE4pNdps3Z+hU6SEhjBdvdZDvItijJDGZvuNY4mRPGE1Z7EbBmkShAix9Cm3fN1KPDZ2SzZ87ggq/rYJUhgU4N+Oqw+vuAIJxY9cNg0gKx5qvskrMCAlAIT2O1TvO+hwCeFEgTC0HJb4tTuJn+K6j7gImaq+tonPuT+/wNgjcAao6QQVl/tt+dRtmsehq/LzPa0KGct1AVWR+5FILN0xfLVTZZf7SrrRI+KHZta54tYBvAnsVi/2EZbuPm9LF8IhBSEpkM/7NINL3CQv8tU7GKyMTOdIVH0wy3irEccrdAONvB5vPII7gQ5G3eH7J3tUkpT8UJwbW38bhE10Pp+qPSjDi3nkxFRJ0aYECWcGk8oIqlYOMIhgbRUHI+OaK2lCOFS3RgoZwVSaWQUVukcrWSuXTYzr5ekKUBTu0NpCqXYjUs2piU7bZsVrZwZVBTYUP1DxSJVTORzZHmXe7fvcff2DQ7vXeO1s69S5CP2Du4zntznuHuDMjKUuye0OgFnt7fZeuUqwbzAiIDZZJe0vQLY3WHrzGmaTOfcOrjFH3znmxTzKSIAM52S3fmQza0Oa9trdNqGRCg2k0u04jMIEXImWgdT4HXxRng/a+PUFHY+2F0x/Oio55gR2g2SSnyvc+k6H5TmQv6w8njUC6butqZj+dIAh0oX4g0a7pAVW5VCSInUoIvc+eb54WyIw7D2TKAG80e5L/2gvcOa34vGv9XHBov8zOURjPR0FWWlVijshGuAvh0YzVs6EGwea+h7K+MMXmVQn3OqGtbGbaxhxbIWUd3XM56mrtc3icayqWVVzJPFdgWW7UtRJ5TxKq5KTPaN5CFIhKzGn2PCmHmSckFeRRrJPJzRkimx2gZdc0SBoEwidtcMmzeGjDYCZlFEqWxIQ6vsYEzBRE4aKhrnjmXqvva2CqFnzMsdtnpXYJqBkcxu3OSb795Edu/yhS99GXUy5dgErJ1/hlCF4H1atWZxtI/qSwhsStFSlGhj4+Ok63tLeCS6hPFYIJMCsBsCBJFEiJL9nuK5G2OO4w6LQEJomJ9MufnxCavFgM3PbbHW7pCNbvPJO7/LIk8oipJ33/02YSLorIZsnz9DMJxzv/0JM1HS75yBsM3xvROU2eX+0ZhPbtxBhS1QAd02XFl5ntW1MyAk/+4bv8bt/V3iWHDhQpd+L0HEXeb5HmmroCMlZ5ILdONnkDKs5gNIpIzcOK+pg6n0xo1R7ZC2ERzt0lc2sEa4seIHj1d2/6gNaX74+IyUfjtpj8GVuNqI6PBgYzMlgZHK6qa0ptQlCFWl3pMCwjC0jeFmjHH3abIVX2yDfza4fBh0NJng0l1+wC1P38s0bqYb15duogceAVx9jTCUlIBs6Oke/uxKi+t+KazvaTNL2jIAN/Y5o6E3rhKSi8qXVQsP0A3xFgfSDYPpE1WMn0reEk/FfIXwQQP16T6RjBACsRCcDV4lFCkCQavUHOV7vHPyh7x+9jXSWRtRWA+U+WjOeHzCzr1jLuwIuLxKZAStRZcX7i0oyoL9swnXL2ZInwBJKiIVIGRIqCLQmpIA3b3EvLxDNkzodNYZDifcPrzHaGh49xsfciHtcHx4wMlMc/7Zl+mt9kjbHWRZYnRJZ2UbrQv0eEEYdpmNx5SLGUk6sBuglrntax2ACGH/mBvHc+7d+oSJDNjeaPHScz1MT3J7q8XZayfce2aNeQDBSsKFc5pg1uInrj7HeDxDr7T40k9/kY/2NN+/dh+hPuDcSy9gTACiZKN7lTVzhVwX3Avu0SkizPouxYmmbRIuXOyxWEC+KEkixTi7xezgBkGQsL4ZsXbuHFpltNKUWX5CKId0gxCAy2uvkagNjFF4N0AN1jaEchKGC/H2hMsYlgJf8MAKdeRhQxKkguJapAS0KRGfsg3vY3IZkzXIUv8WpyxRDfbuRCp7HGNckg9BaTwsgJISvw+ZfQ4PzHdh6hxPP/zOuA1gevDWPxzLdeefvqZakJa+EEgl7Q4TFauyQFC6DH0Nu9ZDyunlQCwdau5q6zeY1LisV03FiWncyhgL2jifZfcy9quGI/8Tqmfwslgl1zim7wUzH6Hn837ZawRCS7aDFwlJa2FEhdy5f4/f/eg36eqQ58NtomALspxwMuXO967xvQ9vcX7jDBuR4PzWBpOD64Sbl1g5e4a42+PMah8pbEL+2XTKYj4nK0r2D49YZDPybEF32/DBH75P3F5je/2Y9z+6aQfGaotgQ/Lrb7zD+c0EE0R8eP07iFuavDSIICYKIgKpkCokX9h37iQJSoI2u7QUHB4ckrQSjqcLJhmgAj748C56NmE+nnHltcuIu5rv/cYHXH3l8whOaH/YYqgLttcjnt04S7x2kTu3b5KVhmvvv4P4eIdy0GdyWPLcz71CoXxgg7BkCrglrnGiF6SF4nCxw1ZynpXuBt1Jn3xyTDpYYY9jlA4xYoERmnayQV4MEZSEekGntwY6w4iIxWxEELSxhrcSYaS1x3ibhYVfmwazgkDn52vquWOo3fqoZD4/GeuZ493y7G7SD5v1y+WxgG7pLMKVH7E7LvE2UpYjrhrqB9su1phj3GeE1a1Vr++CBh6gnQ1DnRcnxNJxL/Q1rmlWwB9pWP+bSa0fUDkswfLDnUSaxyoDSCWyNNQq7p20MTb4o9RWgV0a6qi1h9/XHnBDYknmb15gKnVDPSxqr5Fm+kL/vTb1ZiXGUWFvWa9Z7hNavHSEV2+JalIuh6c3+9VgipJQdRtNa9Blyctbr6GEZLp7m/uvnCWSh7TLFlF/jWfPrrL+hRcoJyUr7VXykwn7wynH4Q7rapv8aI+ja2+TmznkY4zO0GiMLohbMZqS/dkuF9QWZy+vIFXJdHKbF35izSa6V9t89c98vvJEqBNL2sQ2Bh9FphGl5s73dvj3v/ldtF6Q5wvOnGnzyleeo301pdNt0zYdhLJS0vYzCSe7exzuHHPz+JB5ueBgcsJgcsLNoyHD4wOunF1nfFASvZ7yh7/zWwznU/TOPrN7x/zsXc1bzx6g46vot24iX71AKcrKkH4cHDEpb4Nc59rJtxnIDVQYIBAMOucw7XMAKB0xyY+ZiZJ5MUcXJ7RUi4HapC/OEqV9NIaJPmFXXGOuj2nRsWxW1Dkqql4XZmnW+3SN9k9nYPRqUqHd9Y1ADwe6RtReG9bXWVUL9qPKYzKkuU43orL4e/9CCTQ3BPQg5MHRszmljVMzSIS0Gzj6BkAE1D6BsNSe1H6HSw8RHuBMrWY2zfDFRhHNWz6i8U4fbiwcj2K3/iSz9J1w64UiSBLyLCfXBk1JBAghyUttrdPUi4Be6lTReHfTyDFhv/NhpcapHJZc6xyw+rFU+ls5v1LtWEk11oyP1jPVNkO1HvRJKroCW7uVji+ikjasYalxhTZ2TzjtnePrb6WUPLf2Mt+490e8d3+MCk+42nmJZ1t/lSgc0EoVs9mMw51b7B3fJb15h+wbb3D4j/81K9M5rV/+HMHPfRklByBdULCwEuMnBzcZFjm99iqoEG00rV6v8fSiohMuULgx5y0ESwkChQkEBRHrAQxeOsfnv/oSUbeDkT5ZjXaSjdUyt1dh65lNjNFMjkbcu7ZHKzbsz4/ZHWdcv3mLlWTKQa65M9xn9XKf8y+dQ5wckZozfDJ8h4Puq0TxgDtvf4/La32Kc20MBVES8/H0m7SSAfN8gZ4eIlqbJEkH8OMQMIJEbpCEW2gzYRwcslMWbKgeq+3P4xSYSKCvOggBx5MbtLtnQQuMCJDO89xLM0uOz1C5TC4BqxsPtV9ulV7I1a9phLYs2JMWIU6jQF0ej3rBq0lEwwdSeGi14oW2SwWeefrIZhdJ54MVq8FtjQsWPGbzBUVhSOIY9/Y0Hfjd4xq9RuMbe25z599Gqlr3tVj+7lOLWf4llkG1OqtxUOAGuF+chO3OVhQzQ5JnGcLgwFZjtDVweOnBTh9nqDRezeLVB6JWy/oloDJsOgbr2Z3PROUNcZ7BVnX2zLZWI9Sh2wJjZPX9k1YqZ7oGqxWNrG6+LPs2N81d7l/jMhAYwf3Dt5lQslEEPNv/82x1fpbZFO7e22Ex2cGUJ7TaAc+8dJb0W98h+/7HhEqwuLrK+JkLrIcJOGZqb69BKD4Yf8D56Dz4nWor5XstDtcumH4BdVpMZxvwK+3KUNFLI87/3Z9B9AfOBdZKV9olvTF4QHHjy3X+xsYq7UEXjGI+FCTfu8FifsS9Mudzn79A9/wG7Y0W0eyQ45U7jPM2ShbMP/yIxeCYyWSHfHcDc66NMZLFPCORXeKgzcH8iJW4hymmzt+YemA1WKUULXoiJU9y2qqD9tF1RmDcrhm94CylnKHlCGUG1Yj2rNff1Af+uGlkB0G1/To1iBiwagU3VExzjHhdhEUx4/a5+7TY+McDuo1seFpWGoJK9q0nqXD/O32JGyzSWdNtjlfX+S7Zq9aGyWyK1jN6vR6RB14HJB5wK9j0DdQA1ib9936sTXboDZLC+BQW9bUs/e3uUbF1UTHBB4tZ+uR1q+DngyAQAiUDFhRkRU6oBOQapRRa2S3YDRJVqW6WI1/MAx3tl+G63UtT77nl1Rv1fepG8vXzuyw3J4HRXr1gjxdPIOhCrWiymrhaOhLG+2Q3IXd5NfUbVQoBUkakrT4XWq9x9fJfIJ8EjI/3uXbjDZAz0k7CynqXMNpCO4Pc/L/8q8ivvUY2H6NffIb1+P/H3n912ZJkd57Yz4SLo0PduDrzptZZKIEqiG4ALYe9ZrpJ9gzFcJGfgB+ED3zgWnzqN8p54OJaI9aQw+menkbPNNAoAIVCVXVVZWalulqFjiNcmhkfzMz9xM2bNxOozixgIXZVZNw4x4+7H3Ozv+393yrHp9OudS0QfiEfrB7ykr7c7eguAK7/v384+SCnLCtiPKlbe/bSWSSSjccLZseWm69MUCrxYVHWg7UJAN5/Ps6B6IISFKYlGTzi+ObrnH7yIdPRRS5cuc/1dxSTawIlTjg4fo9cXqN97TIP3V2mx5rh3gmcHDO4kPGj2/d545vXw1pxDMQOrZ0z1UOkPfa0aL8lEkEtPgdf+EeyxRVEVSAGkr5wUOTfFRvDl0mbQ4wIQLi+NsRagkX8u1sD6/lm/SYb/VG9lRiOcXEe9efrUejp8tVEL3jWOoJ/AFyHsH4iGaIW2YckdYE2HbHoH4pFYEM/NKUTxqMBw3yIc462bUFKZJJAyJgS9EVDngTTThvt3u8faNzVu7ELefIyatEuGGpru5hfpCI88B601kHerQFefx+OWGvIAc7akHbpuevWCeq6JZGWNNGo1pEoSBKNdBYDnssTEvGMh9uFugSNP16j02Y7T+QT4+EEznqzO2banwnh8GElvvas+4vUIv6rIzFEygNsKKEZraqoCIhQQDymA65lTwipSFTOxvgCKtugMQmP72r2H/4CYeaMx5Ldq5vIZMd/wLlQ7N36IuYK7Osv0j+IEJ+NXxfxsToERla4ZBztRJyVWFqUjC12HA9WB7x/8gve3nyToUwRNtJKjpyE6d4BlbYcXJ7SBoqkT43oocZblVGLdnTdb4XDGDCnmnLvEVvbWxwdf8wbf1cxHQ4xew03f/op17/3JoneBTmh3PoZw//0XZ470litGL9yiR0ZbDThtfA0SUjTTVaLOfcPT3nh4qhzIvvLxkW5voYcKslBj8K5OjjuARVo5BbSiuD7EmtarqLvm9KPIaxvVmchuFPewn31jLBYfxGQ4bt9zaDbxYCtmaq9Vr/25YJZFNNhxRmAik4BWNQ1+0eP2drYoFgJBnlGWRTkA1+UWBiBVBqJCE0lRbdGurW0hr4dzETlGq9BRx7PrGk1nRYr6AA4KBf0tR5E/IuOH4lc5xra9vAmejMdfCcG5x2QtbUcL0rmJyfsPbjH5sYmg0yzuTFjMppA2yCNZTSdUrqafJDHOfkZ+O1MxcDbGmJpPxcKk/d35tY+5EJcuA2abhiB8D5d2N56Kdi/bhIZur4Cn+iBGEHVgBYOG9qda6lRKkMnOVhFWTTYCu4eHXFw+BHF8iG1fMzLN14lTS/5jc1ZD2BdDrejT4ZY09+iKRGyxvpnaTmsTlmaU+rMN9OpW8etu++xuTNia3wlbA6Cw3LJv3jv3/D99EdcmFxlezhlO58wTYdcMXC8aXjtwhvc3D8Cp+mDBbvSOOH+IvDCejWGSMHZbIhyln/9Zx+TpR/xze/scLT3gOmjLa6+/i5abWEdJHpMpqYcqV8wunSNzc03KMtjRhkYd6mbT4Mk4dS2nD4sOJk79MWeHIvPqXOc0ysZoTRRUGp8kSgPH2sRBAKcCoqE7ONQBD3I+vEXEDYBgfDV0hxdmKAfqB5co9IS+odAuEe6MZOdM/Np8tV0jpC9g6r7LX3kWlykQfkikoKyVzWQAozxg6QkLCvLJ7ceUbagZUtdFNy9f5cXX3gRrRzPX7vExmziK1sKOq3Fx/32Wm+HTtDVV45j5U2QOMT9I3HhHmNM8Pp992HTvWnRc5wx5Kp7gY53xQNg1LiN9VRKYyzWWKajIW2xQDqDFpb50TG2seztLymWS0ajnF0Dk2HKMA9tv5+ysUZ+TwjRa6M2OM7CTk4A1hiVEMV2HC7EqAVwPorkjEf/rOX210WU9DUuorJva0ueZBwfVcyXNY8fnpDYislsRj4cUpuWYnnI6WLJ/OiQw5sfonTF27/1TaZbEyr9kGGuSdJRiMGO2pFfmnSbbKBtRGyHHiiDDnDDyIbn9tOHf0aqM1a2ASwf3/kB5fA2hufZ4DLzpuTj+UP+2w9+HyGhcSUny9scloo7iaatW1In+J3rb6IuPKSRNRkbHWjFeHFBLLm6Rnt1Wj4gBZU+ZrHc586dIZ/evM23/uGSxaJkQz+HuPEaic7DNxJYJ9jZeZuH1R8h9H2Oyj0SdYIrBIP8uwiuY4FhOqJsGh7ffkgqJYkchIuvLVDCuIgIdYGQFBGKZV9drFfziEH8Ym1dI/xm2HGI3bayhhMuWsC+RVLv1+nfi8jSURrOAd7B/6SP6En5amovRM4xamAChPSTTIZ7j+9L5GeGCnxtXOccjXNMhiOuP/8yQsJouMFousFoc5PpeIR2LdPxiDSA7ZnMskBTsDY8ncS+d+HPblxFvxd0r0dAPRPv3F/nM3uaW9McWUsMdP0V12vXRoAj8f2dLI5Lk+u89cLVMH79sX2wmejObOJG8qRHS9AVxwaHcBYdPtWGY2PkQuRv43n6hUfgdMPENEGDsGc/89dNfvqTQ0rjWB0esb27wWi8ReIKbn/6KQ8f3GLv5IhRrtnZTBmOMgbDIQmOh5884MPbj7m0O+Ef/kd/l+n2Rf6Hf/WnHO/8D3z7hX9E13bdResgJv6GgaRnaLrNGbqH4ESfA+ic4Pr0Gu8/+nOq4gBmL5Nun9Aowbw64L+7+c/55OZNjk2NHTtGeUKeJlSLkqp16HbA65PrfPPKu6STKctmycBmPK5uszt4bi1Bx3UWUKd0dF0fLEJB4W6zsgdkq7fZ2h3y679+wPYLB0zs62Sj1/BQ4tbmvmE4uMzV9GVqfdvXjJZXadqGpfgIaU8YilepZMOkyEjFilxJtBhE3THcXAhU73RcP/ujI15iQayXgF//XG+debpAeO6242dDwZrOmebWnoPjjObYcfjheUbLfI0KInxvf53Ph9avNA043q9/kY5j6AGjd1T1oNsbEA4QynFlZ8DV7RvI6PwSAhuASArXa9Dr16M7IeujEgn8s6+eHd+zx/diPwdfxBN/RWD87IFPP4EV/fd3rANZTJRYdxKuA3g3Sp9zX2v3EjcTu/bveEvB+9vfpn/XV+jvHWbrVkIHxk+++ddE/vt//q8REna3N/j4ww/Z3M545cY2L7y8xVvffJcky0izHKTqN1BjkKf/lvuf3OH3fuvv8jsHW4iDQ9xzl7g3+duM1RDhbBgvB052PdViKxnfUn3dUee68fVWYLSKPLTcmL3MxeMd6voAKxx6nGFPTximY6Yjx/a2Ybud8YE7ZNUahDH8jtlgtnODq9feJlUDnBC0oqG1lkTkFKuK+/Yml0bPA/39dk60OLecQ2eOMnmEq+awGDP/oGWxeMzGlZrNwesMs9dxLpj0rp/HXiSZ+gZDNWEwfEBrG1q9waKscHZOVf8Mudgko2RzmFAYSF22VvTn7JxyiFBPJCpqERhDC6V15OjScD0oh57HAWhFB8AIE7dE4rbjOkeb62PYu3uQ0fyDDsHimz1QuydGYl2+8m7ArhvAIOKJv8OLvXUQEigEYWBUSKqQsdIcQoCK5u6T4P45ItaR/dlHPv3Ap1jwTz3d+lf9vJty64FZ8WP97tTXPwAnJGcq73/m3OLMhvb5cnacuoQLnLdCBL5B5pq2203igM7O9WDsKYc1QP5rJr/zt6+wMd2gbS3D6YgLF7cZDMdBr3K0XfSGW+Nc4bW//xvcePUyv/1oi63b/w43Mvwd84gf/+3f4yjPOmrBK08u9HgMyQnrS9HF+gpx/Nbpqu5FJPD27Dt8fPpz2qSkXu2TjnYRCIZuyBuX32CqL/Bt4I/v/JjfHl3hsr6Au+LrQjhnPX9vNcb4XKxrmy/y/33v/8d3Xxmwk+54rHBRS+0rjSVDQZMeYNuWeT0nr29w9ZXn+dEPf0KbLhkkb9B3Yu19/dFSjApB07yCLDYYbjxAySW1rcCW1HVJ+uCYZpgwL2qyNCWVI6LfxK+53pzv5Yk4aREj8+OMDg61zqnmOpqwowqFT2RwYRPsd4z4feIm0tmTTyyzcFyHZ5FucE847T4rX1mPtHUTtRuPuCshsS58mafgUhekEswHIawfRCwSX5bO0xN/Ue0qAo/43J943BmKRKx9BXrCQIY9V65p7PG+vuje3NqP30jCJBE9Ly2Ff5Qq/PtzzxgefPz8+vX77xa12nD1MF96hixy8f05pASlRajs5u/WV9zrOWBrQ6ryXzP55ve+x4tvvsar33iTay88TzocBf49aH7WdT+safRCKoZXrnPr1vvYRCAu3UDu73H1D/8L/AYYtUXwMGQ6MIrBYHGhW1w/nwIgiADG1tnOEfvc6AVOiyMeFT9HpDO0GiOkZJANabXjyBzy/OR1/nfP/wdcyS8iLr2MsBJrfc1ei8FWK1bzFcL59lBv7r7Ff/2j/44H5V7AuF6zA0jyjDYrmFcL5os90gouJy8ymUxJ8oLdjW0E2Vp6eNyI48Yt8GEFEoGhrrZYHb2MZEKWDBlpGKqrDGa/hnPvcnTs0DYlySb+cyJ8HojEZD+H1ygzRG8dhDnqDwlAGDa7LrZ5HQxDWx/bRTJAn4OJfzIOXIi3ElHBob+v/rrhmk7jvgBWxVeRyvnzU19mRQjvHRYBVLQItLPrgUyvgUkfxeBrLwjb0wmePok73GcB94vgdz2G90l52hj0lb4+b3yedrbAfK7Pg7+gPLUV0FOuuU4v2DPHPf1bdv7psBmaEAu9zukCGGdxVvbnd3iKAR9d0dEN8TwhY+03rv51dKedy7l8/fKVaLqfBbGgJREWuehB4qmNHp+wWcUaiP1Vz/fvkjlY05LjDv1LydNPcCbI+0tKH6p09l7j+Z7Ulp88bt2Kkc9Uwc/lXM7lSfnqkiNiEsgafsZiv/0ajWFV8djAaa05knwx4fXPfJ6++nXJ+rU/uwFIscbW/rJ8p+i/t1s/6fodBI5qPSrtyff9G2unjVq/EGvBtuGYM5xueDkE05+5DxGy79yTFdPO5VzO5VnyFTnS1heuV2ul7sGob3LRUyQOh4qfCz+RQo9JamfrXP770B7D3X7pE0XA/3zaoed9+sP/Isr5+r08k2gIoBfDXdbDys4e19MHLjog1ugdKdecYWuXkFJ8rhXioKvTG62XczmXc/ly8pXQC0r3ZHQsArzuCV6v4uOdMWdVwsg1xk72ztrPw7i/0rLOlX6lF3mmiDObk7UuVJOKn3+yYtn6qdc8+OHg9XO54Oh5VvbNuZzLuZyVr0TTTbSgacF7/6K2G4OLozYruv/6v+nBOa7sNW0qar6/rHb7l23n8xeR9Spln3GqheiBLwvGX8hhr4V+PXGRtXPEl9buy/WRGOuUiGccAg0Uvoe1fYGQWJYz8tTWCdS5qnsu5/Kl5asBXaBdD4x1IbijC2PyL/eNUvxBHpTjZ54aZ0DMBHlWoZdnSYfnX1o5+7zrfMnrr1GmvfPwS176MweKz7wl8NnmpoPdz7kvFzj16CQLYVBrNG53sxKwZj3zZo2iCLxCaHSCQ5xzuudyLn8B+cqSIxyhpK90EHKde6B8suQEdLF+OIRcqzL0hHncaaR/aad50LC/FNf6SwIunwXcX176M64XC/qi2xKAWtvIonL6tIy2GOrnbBzvUBjG2LPHBurBb5Sf3xPqXM7lXHr5ShtTQjBD13rI9DnVHno9rK4TCE/BjjVc8A603uHWXecvcZ9/EUahD5l6wnR/yr/OJjI/eSLWRuAvLzEj50zxmXUH3pljBU/ucPHzT0+ccWfu0bmQFIEvPYntNd7z6NxzOZe/mHw1mm5wsDghuuLAMdMqLmYRzFglXJeC2KUvPMkRxs+5z4LeL3eTaxf4Jc/0RMBCJ3btoPieEGtNd//SIog9vZ6MPPgiCY+HWG81lqhzEKpyii7lui+pvfb59Thkhw8RPJdzOZcvJV+Rpvuk88y/HtNlY+lyz82ereJ+xux/6lr257b287PTPu+ePkeP/nokABTE79drqH+prsVP43ujd+xzrt9/uNeUu7efFhPchZf1em/UcH0qpguJruegey7n8mXlK9N047qVInKy67XWXc/hRvXPcZafhE7ziqGvn9HoInj8ewna/XynFYR7e+IocebfT4P09UI+9Bp7R6t8gazvQB1FsDY+XSrwk+VzvljWMftJKuFZG5OQXk3vwszc54ecncu5nMtn5aspYi7WmVvX0QIOuhYpvqj20xd3X6vS1wiQLnxARAfdOsid5YM/T9aDKZ5yxSeP/sKjxOf8+8vK2ZpJT781D9hdAcB1vfQsp9ttPH+xe1jvXuH/XiuPtx51Ef9YB2rR88HnvO65nMuXl6+k4M25nMu5nMu5PF2+stKO53Iu53Iu5/JZOQfdczmXczmXr1HOQfdczuVczuVrlHPQPZdzOZdz+RrlHHTP5VzO5Vy+RjkH3XM5l3M5l69RzkH3XM7lXM7la5Rz0D2XczmXc/ka5Rx0z+VczuVcvkY5B91zOZdzOZevUc5B91zO5VzO5WuUc9A9l3M5l3P5GuUcdM/lXM7lXL5GOQfdczmXczmXr1HOQfdczuVczuVrlHPQPZdzOZdz+RrlHHTP5VzO5Vy+RjkH3XM5l3M5l69RzkH3XM7lXM7la5SvphvwuZzLXxP53j993onQWbNvNe/C3yCERAiNkAopE6TSSKmQUhI/hxPgRPf52HdQ4Ls5O+ebs1prwK03rG8x1oSGoHD2PqK4rim0EKJ7z5/Trh1nwtEOsIBFCIcL/3bO4uJvZwCLdQbnDNYZrG2x1tJ1j31CpOz1s76vojvTlFQIEPJsz0U/hv6+nYiNUCVSKoRIkCpBCh3+Fv6+pUMgEEL1YxG7hn/mHrordRcUIkEJhRIapVT4kV0zV9/UViJd31zVIXBOhmcpu9dwDofpxrT7wNoc6Z+UH+//9//px89s1XoOuufyN1rWF6/vQg3gPMhICUIhpfY/QgXwlWcAUAiBCEZjBMezwOWhRilwTiCcDddVvpu1iMc8TULv6whe/oIIHE5IPLgK6K4fgSGChAUc1nqAdULgnMCtgb9wICJIW3+v3fd4yjj13yl+3/61s3/3n3W4fkyEw//pcNbipMVaEcZV4qw90747dgb3fzztXvrXhBBhg5HQAX485lmdq8Vn/imwoQu3e8rT+Wx78fXbfJacg+65/I0Wrwl6NUrE30IipEJIiQiAK1AgZABXD4ROiLVPBm3OubVz+YXunENYh3MCi8AhAsD53zwJIo6gsYUziTUtbU3zcziEWNdAQcoItgLnFEI4rDNIGcHW4vDgK5zAWgHS4ZzyWrj47O34c7snNPAoPfg4J8JfLmwO/ddxLt6vQCI6g8LiwNpwfwDxu7puLF383p+DaD0Ih2PEU14HpFy7of6uu/f9PTtwfiML20/YMNxTAFt0R/C5YP5ZOQfdc/kbLc6JoDlKEBKEQCqF0AopBAIVQC/QCVJ6bVGKbmEKBFJIb7RKCWs4GkFMCkFUQk1AIX8+i7WKJxElAoQHOn+ts6/BGdjoNEDR/bhgCksia+A1XOcE1pnuvDgXoE0FU7o/31k64yzw9u+ta5Ci02JFeM8Jr3f3tx0+Z50HfDxVYq03Lj4ja9pt3MyevgGEg598RfTj2B3i+vGLO4BbpzLi6+HYuAH6F3paxzkXTIWzgP4sOQfdc/kbLp7DE8G0lUohlQIkkgC2qGCmSpwAIQXICNYB4CIcdP/xq1UQTNw12kEgsdZzrMIqpFw3j8+axJ3mHV6TUq7xigQAC9ytiCZ8/DHhINkfK/zrnpiIYOIQwiGERQiw2DUkXecuewCOWv3TqAR/zu6j/lc8lejxzuEQAbT853o+/CxZ6rrrr18bPgd8w3We5Mh7zl309xXnAF7r7nn6Xnv1Tzk+YdfdB8J1z8s98ZlnyTnonsvfaOm1NIEUCon2P1GzDVosQoEUiKDhrlMKMvKpcfERAFlER02PPjJwhNZajDAEn5YHnzXHVP9bBoeS9JyyEDhhPX4G0HLrAOlsZyxbS+B0o7asiHRpYD09CAqFwyGF1/YUbaAhguPrKWRoD35ngc/fU489nfEeNwMRv5wAZKA8/JHW2qDpeoiL9I0M7z8JvE/eB3hH2BmttnvG/WsRQv13F2u7Qgepa5S840nnWa/+rn3n8PfT+OYn5Rx0z+VvtPTUgfeoKxU4XBHBVnROMyd6MI3efE8riACKnuvtzo3oAEbCmknrENYiROMB0AQOIkQY+PsS3f1FB5OM/K1Q4fwOIQxCCKywwQwWHcBJaaOu3d2XlNIDi1NgZadlWysRTrNuT0eHn3fLhcgG8XRu14X31s32iGc9Dq3di5BBd+xBFwjAK3HGQYwQEY6nKcBnrk1/js++/8TrnYUS7ztqt2LtVw+0Ub91a695IHbd0xY85cY+R54Juv/sn/0fHU5QNzWHRyc83tvn8OQAmSnefOUlXnn+RXamMxKRYJqW4+NjPrp5kx+99wEffnqH09MVVW1ojMEYg3PO81nhe6owqFpKlBLEqSSF6LidaNZ5FV5inMPYFtsaWmNx1mKt869jwQmsCwPVmTIiEPl2ba/yO52M5pxUfod28aiw0wrJaDjmjbffYXM243f/1u9wslwxGI1wrSFJEhyWi9s7rMoKYVv2DvZ5vLfPwwcPuHvvFj9/7z3qpsZJhUsUVmusdFiH995a110ba3CtxbUNrrWY6IQBhHDIoF0pnOcJowfbRaZJhE3YYdf4KOfWjGAhgmnnX7ei58sc3doKH7Ke6wsHez4wTsY4DV1gusJ5ow0pLMJ5RtGPf8+HxWvUxw+//Gz9CkQJ5TVcmfRRCjLwu7Jn8SDME3rwi3+r8Bkhgwc+aHGdWb9mbgv8czbWYITnPhGe33Q2jpv/UJz7xHCqCMTrX6AzbeN/1k3/qOFKnJN9aFp4zkgH1iGl8wAdzGMnEoQ1eHrCrV3P+md/xvL/LNA5BGJtDXavddqtxFmBC1R2vM9O43W2m7Qe8P33lC5uRPBZx16vSXvt2XVzOf70QxaODbSFPfMdxBOfiPztk9puf8z6+Hwu1bwmzwRd2zRYoK5rnLMorciHI7Z2Zly5fIVrl6+wu7HJIBmAtSwWp8wmYyajAaPRgA8+vM3ewQmybmmEpDUmEOZ+1zTWIhBY61BWoAJvpaU3O4QUaCE8IEsddkeLtRKrLU3bYlqDMRblLFiBcXF39YNuCI4E4TBOdkMogkkR/ycR6EST5TnOOS7s7rJ76QqTyZSLu5f4tW98k90Ll9BJGiaeRCUK27SkSrJcLUAkOOe4mAy4cuUaybe/x97eI97/+Bd8/NGH3Hl4j+PlglYKWucoqpK2aSCYe35BgwgmoZDSb1bxgXibMihPQVMQApwE6eLmC8Ew7DUtiGtWil4D88qVC/ya/5wMbpfOESL8PflNCO8MCvpYbz7HEfQaUTgc7/HvuT//RGRUL7BfZoZ+1RIiFaQM4BtMeSElLoypEN5x5kG413yFEKhOO5YIFSIe8JTAeu6RJIBa3MysjxZwLm6YNji6ekCJoHsmJjhKoCMiYDwJfiKATwRY/3HZAZbHW08y9Nq+DeZ279iLPGs0n8Wa4tLfSgDAbh7FvSMCp+g2Ded6TdxZrwidjT8O38VahPTRHvF/kVL5zHXXtkbn+k0iOv/OjsvaxvUZXnrtu66B7lnA7oc/KOFnOOYvI88E3aap/fwwLWmSMp1OGU9nXLlygcs7F9nZ3GZ7c4tBkiOA8XhInqWkaUKa5AyzAe9/cosHjw4oVhVVC9IIjBDekeD8pLFCYCxIBEoKnHIo4dk1pNfutBQoJbFIrPPxfUpAjdeYrfVarwwT24YZYMJgWOd3Shs0WRdGUAp/bvCA9MZrb/DKa2/y1ltvcuXKdUCSZSlSSk6OF8znS5RSWCFJtEZJWJQVy6LAGEPTtgzyjLaFolwyGA751jvf5s3X3uH45IjVasndvfv8+IOfc+fRA1YGvxE5000oIfCL3hkPaiKaUHEqh41ChEUR3+qnxmde93PTf18VJzgOI8NE6xyyazu4gC5cSdA5X/xY2mBNhrFbu7sO8LsL07/qovYjPgskvwIRUiFETHgIP0oFjc/FVdVbXER6QSNj4L30wfcEWqLnXxVeg3OILknBgRVek3RJ0D5dAAAbrLL1a/amcBRrw2e6mfykLhe/nOieT4QlF56UjMq4URjOOtL8B7zd2WvHIV4YYI3vfcbI9lyqE91e04F/fN8F7jmCr9eQCBfvv0cXPta9tCZPqN+sAW746d+NDs8n7j5aZt0f8dqsjWB/cOeUE593zOfLM0G3bhowBoQiy1KywYA8z7ly8RIXtnaYjCYMByOyPAcgSRQ6BpELiUo0+SAnG9zk/r3HnM5XNE2LMYIWaK0LXJHFODA4DBKHxMmw6I1DSEmMJ/GTHkQAYWX9Di2lwlgBxp9POLBCIK3XIiQecGWwHuKGq5QiTTTbOxd45fXX+fVvf48Xb7yEsS31qmCxWFLWtacshEInmqZpaa1jOMxBSOrVisWqoG0alNIcHhrqumKUZ4zGY4xpqZqGtmmZDkf82suv89zFK3x69zYf3v6Uj2/fYr5YYJ1F4RDOUxvW2WDWh0kWzFPnglYkfKxl3I19HGQw/AW9iRfmgwISBBLvMInLyToXjo86sr8HETQbiQxODeGzhYzD4D/gteHghT4ztaPS7egcF2f4Svclp+hXK167lYFi8MkProtbiqAbtHr8ZujBNkEp3WU7SSmRQgfN1COaCBxvTIQAT7Eh/SbnrEJa3W+4zoebybDZhYft5+sTWlsXqvQUwF2PAHDxOQV1t/PASxA2gLuLmq5GiLbTKnFxTkWP/zoBFS2XZ0mklVgDUtFxvX5sBIEVJM6KzlHp+u/Tb9DdzPrca3oNwltUbu1n7a7ObPiiswzjN+pDwp4Mz+vvoXs0uLCJdd/1C+SZoCuThKatEcKhkyFpNmA8nDAdj5kMR+RZjtYJJNprQmLAANhyxnNW1vl4RiVJtOLeg8ecni6oqhbRCpwxWAvOmC5+xVnPGxknUFhaBIjWD4tzHXcWF3Kc8P3uL4JTALCmWzcRsaz1gCOlRumEV197hTdefY1XXn6Nzc1tTOvY39/HOctquaJsWtqmoWxbnHXkeQ5CYGxLohKyLKNpGg4ODmhbC8ETPBwOqMqKVVUzHqZ+ApiWg5NjkFDVNZuDKb/+2tvszGb8uw8/ZLGYU62KwLFaBBJFzzHLsLPKOPHCZI3TRYSJFhU0F036aO9HE1HQR2QKTwxE2O6nYh/uJIN/SCA8T4zzXnfCZ8WaZm27KdlxcBaLdGEhhzCbpygnvxJZd55JqcPzi1q4DRpgb32gJEJH7VYF4PXg21ETncnL2m9HTE6ImpILAG9lAIjIrQfg7sDC9qCxnoLrTXcPit016DfoXvxzkwRT2K5HNEQdTeBD4wKohkkknFoDojDHwt+q26KfvF53h2v/Fp2jMT76LokCTzVY2QMtgTaLccRn58pnM+ZYP6vzXLQTsrOo14H3LOcdX49ha+tW5ZOAH0aqM+ICt+/imP17AN08G4AxNE2FcBYlJVJJtNIkSqOVRmrVP2UNMtNkJmc8mXBhp6E0LWVd05gGpEMnipOTFXVZIxqBag2NgxbnzZag8Tpr/eQLg2GdV2KVlN0El1IgZRI0Be8X0DqhMR5CTFl6OsH5BTOZjEnSjHw4YmNzi52dC7zz1jtcuXQFrRKsaWnrksWqwDpLsVpxfHJKURQgJEprTpDexxJMy0SnoBRlUVC3LVZ4beX05AScYzydshoN2Jz5zUpJwcliSWMcWkiUFHzjpTd45dpz/PgX7/HeRx8xPz3FOoFKUoTw1oYUgs2NDUbjMa51HBzsYdqm01ycEJ7ADkRT1CS6yd0tVr/gvAMupH2ubdHrepN1BOcmnearkH5hyrDAo2YWNBMrHLZzZESNqLO/iBRDz/H+akXGyAWhEeiwtck18AnaoRAIpVC653CVUkjt6zF4p3DgsIHOIO/y+EOWk5PeshMOlEJYhbLaO1PjPQXFwkcVWG8N9mjwhKzvYE+Ot4Puu/i/LI7oD/AoETnVcJyVhInUfzacvqNCOnogJlWsgf6a2R6v4bpAOT/WNty26JSBSF34yAoimOEtuajwrzktngK48Vzxnw4rLALvQ7LWsh51cpaHPavFRt67My3Xzv1URkx85h/PlC8GXWsDcFmEc7RNQ9M24BwqLlHbhoVrgzdUkmUZo9GQ6XTIzs4mi2pB3daAQ0nF/HSBKgVVHaIVjPX0gLXeqRQnnAWn/OmtdRipUM6RJnFa+51IKcVkusHrb77DYDjk3v173L//gOPjI2rT+uIWMuXC7hXefvstbly/zng0wQlFVTe00lJXJYvFklVR0LQNprWoJCUVgsVyyfLwBOEsTdMwHI0ZDEeMR6BlhrWWtm4oqppVuaBtDYN8QGsNdVWyKgpm4wEb0wmz8Yg0zbDGoKWgNZZBNuIbr73F5mTCx3fvcXCwz/J0DlbznW9/lzdfe51XX3qF5emcP/rBn/DnP/kh+4/ux/SmjvvtTTSCFemi3ypmOGKlCNy3Q7h1HmttrRK8uiFVVQgXloVFCoFVUasW/fXBa0fW83VRe45aVfy3C2q4/HJz9CsVH3Fw1jnWj0Sgs6RAKolUGi0DHSG153CV/yHE00ZLINItkY9dd2hZG3lfiZMSJ1Woy+B8uQchOnz1lIZ/DjFutYtNpYMCuqPFEwCC3zCliJUEwmbnQuJE0Cj9Pz0wGRcZ+iguHLMO7uvafK8dx7nUfzpuRj6ao5ubItBX4uzYd3e+ttmdmZTxik9qoN3bImwQXuMVCKxTnaYbQ9LOni/QCevxuPE5Ruuh2yVkt87WL71G5H2hPBN0tZLoJCW1FqQ3D41pWK2WlFVJ09RkTY1yfhd2zquj1rZY4XBakGQJg3HOdGPMxmpCWRdYa5DKoeYKUVbIqkU1hrY1tE4gjIn4jcNhDBhrUNahlMOhUdIhhV/WSiqef+Flfvfv/D1uPP8CL734Mk5IPr35KZ988gm3bt3i9PSUi5cu8tzVK8xmW+AsVdVwMl8yHg48MC4WnJ6eeDMSicGDLm3LqihYrlaYtkYJwWw2wxrjTTXnvJPPtiwXJzSmQSWp52Stoa4qlBAshUMISaIUCkuiE4xpEECSZmTZgCu/domXbhzz4a1PePjgPv/Tf/SP+eY3v8X/+Pv/kv/+X/xzUqV569XXcBL+9N8WHJ8ce062mxzBgIv7Ic5rV1EjcYHCkYTA+rWp4td2t7DBe7itk6hOQ/YHqDgJbdBqRbgD60/kuuIpcXraQI0E4MV92Tn6lYrovPfijAbYabcBcLXynK+SIZog8L+RD/bA4rX+uACjw5PuL688yECz+JRijZUWLdbHpF/8UiqEExjXIKUP1xM2FmLx3+AzWu5TBtaftt8gPXkCAuXvUpieSolmeNRhhQiREIqem++dbpHv7ewrcXYMo4bbbxH+twz3LiOKRTAO23sE5fh9rOsPixE1/YMUfm4TlAkh/PwO1dSMVf5ZIrHO+nnYkcb95uG608Zd7wnfQ+SLfwl5JuiatgEcWifoRKO1AgeLxYKj40Omg5wkUeSZP401BmsdVdNQVCVVU2OwSCVIs4TRKGcyG1LbBidBJYq0SChXNeWypmoaVNt6JxshHMZ6AGgdGPzkFMbSmhaJRmcpV65d5/d+9/f4wR99n//qP/8v+O6vf4/f+72/z9bmBa7/zvMUp3Nu37lFY1tWy5L7Dx5SVRVCCoaDIavVkoePHlPVNcvlEq00o9EYJTWr5YrjowNWy4KqqhFYhJSUZclw4E1NZ7yWvFzOAwcuEdbSNg1GW7R21HWFEI7hYIBMEpI0B+eoakNdNlA35GnCcrFgNhjyrVffYPDNb/P2m+8wynL+4d//nzCdbvCf/T//r/zs5/+Ob37z21y9fp1FsaStWkzksegnTAybE4H8dYC0DiUc0nqN07qwuXWcYdQS6DOsjHfcSSU7Q1CI/rcRhIIurv98uJveY91rxXGxuL8C1Zw7DUtEzjlWu/KedKECjRAANmqoMhbE6cKtIh8aT+zWIjXiRkYPN8JH5hDAu4M46zr/xHqChHMKX6rAdcCyvvhd1Fx50vT2Ys84k/oNr9MyXU8xyGjyi/VrBR7YdR6FJyJqIq0hei3WyVDPQHaUwdl7FGsOvv5cT+qREV+j3SS7eRUdfAFzifRHsO7C/LRWYmXr57kIGW6it876qz8ZPuYplf450F33aTzDU9mfp8gzQbcsl0ihUFqTpSlaalrTslgueHygmAxzsjxFqxFCOExjqduWsqlZFYU3yYsVVevjfHUqGIw0Y5OBsKSZpCxSllnNSlWsViVVVVELAcLStgYrOFNuzhqLFQbTQo3g8u4l3nnn1/jn/+V/ycc3b2IELE9PqKqSb3zzNxmNhmglmS9WnMznOOfjY4uiYDwekSQJ5aogSVPmqxU4y3g6RjjFqio5PjpmVRSsqpK6qdFSkCUaZ2E4GmKsoSqXqMDlKqEoqsI/LOlL9+lkRqpHKCE42NtjOhkznc4YDgdMNrdYFSV1XbJcLkh0gqVhkCa8/NwLSOc4Pjzk+OAAV7dsTmfcuvkJf/r9P+C1N9+muP4cn978FFvbzkrqIS9OJotzootXdqJjz7ridWcCxJ2fzDZweK3wHLAKsaRCghJ9REMM17PWYS2YtUwmv759ZK8IGo1y1sOF/dXzC37txGI3a04w4WkHueYkk1L0gNvxoH1CROdY6eAh/hWiQQg1baO5LixCSSQ6xK47hDQhquCsCS2kQMTx6gDMdWDbpeTSIUN3D+tOuI4gWKcvwnchJiV4WPMKRvg3rHOgcm0DDTAXx6OLKfbhRzZQNAhC7Hd85n1MiwjWU9y0ukiRiLRrQOi/s3coW2d759yZ2sLxWA+altYDr+2dYNHhGzPe+vHsr9MpBx3A9wpEV03uLzGFnwm6bVsjhCJVEq0VidTgHIuqYu/4kO3ZhM3ZlFGeISU0bUvVtFRVzbJccbxcsFgtWa2WVE2BoUaljmykcDIlzRRZ1pLolERotJQshUDKGh9UJmitz0+Pk9LhaI0vQTccjXj1ldf4H3//97l56zZaa9I0YV6U/NmP/hydDrly+SpSCA4OD1lUleesTMvly5fIs4zlqsC1BqxjNBzCcIh1MJ8vKKuKsqlpbEumFa5RGFPTtgoJZDohzQeslguaqsGaluXylLquqduGLMsReIpmc3ObNNFMplPKYsnpfIGQgrppSNKMJE0ZujHz5YpisWKYJXz0yScM8gGnpyecnB7z8MFDdJIy29yiaVv2Hj/muctXOT4+5mB/32fk9fNtfZ6GidJzWVb0YNxppP18hO69YDo6C07ipHc3OekCiPjPGwvGOv+84kR1EidCiEVnWjpi4tVfBREyaqkqaGjeiYVSSCV9lIJUawDrtVLWUocjRSHXwLDf+gLMOAe0/etCRBODLlrBhsKPMnBroo92kEEzttZ22uO6FuZcSG7oU8DOKoxROiuErvYCQdt0IgCsCDEza3PCV2EzYQ4RzO4AbEJATCw5k5EXL0DQVAO4xncEfuMRUVNlDQD9C32EQTyVxwDbjWtIn/gc9ItgbG3rHfHCQShc1KnQ3Wzsnb9CRA0+jrXoNoW+6LzqgPizoP/58kzQHQ7H1E2JcQ1gUUrQGj/URVmzKguaqsY0DUJrjLW0bUtVNyyLkkWxZLFasiyXlHVBa3zol04sI5ViEkuSJGiRIm2cvCALBa7CigZazzeZ1mewmbD4tZDcuPESD+/e4f7DR4xGQwaDAWk+JB+PGQ7HHBztszGdopMkZPs42qbl4qVdBlnG8ckpUipWqyIAuUQrSbVaYoJ23rQNi+WCYllQl4VPiFA+c83ETgBCMF/OadqWum0oqoKmaWiNRemU1WrF48ePeO7qVXSScGF2mWK5ZH5yikoShCoYDgdkgwEIgdKKpih57/332JxOOFnMOTk+YTbb5vKVGwynm7R1Rao0GxsztrcusJrPMcbQti0xCiR6iXveNnJ1IYWYPsvMBBMT4YL59USMpwMrbTA9Y0AbHjQi1ruoEXlKw4mzK9+t/cfHGH/pefqVia+xICICdOa2lLJLljij0YbfiBjF0HOF62Z2TzmuhyL11/ChTE/eDCHbMXDnPdIEc33N2deFOflrwLp5G4AkfLwrywh9eYSnjQXrjkTCOUOctVDr2NSZ+3ROsD5krr+HOCL+JxYGQthubHw8cnAMCkOMHu+/9Nr3Wbun/t/+S/U0Q/97vSKZdS2YkAAiVXTBR5XiDHe8Tk/0e0Yfc92nLbu1Z3H2vp4lzwTdzZ2LrFYLynKFs6arPi+VAhMKIAv/BZVQaGERFsrKg+6qqFiVBauioKwLqraksRVCQZoq0AlKWYSxOCOJRL/Uvjq/KgVl1dC0kgaBNCaEfvjwr8sXL/LeT3/KcDRiMp4wnW2wsbnNbGOLbDhAq4SDk2Ok9BEK1jmmkwm2qTk8qtnd3aUsKk5O5ozGQ/Ik4cHjR9i2Jc8SThYnzE+PmJ8cY61FKUmepUwGOdPplMlkAgi00kwnUxIpqcoS03it15qG1eIIXEOmFYdHh2SLJaPRiOlkjJ5MKMoV1WJJW5dYIToqxRjLdGOTqq4oViUvv/ku+XBMsVzynLW0tmUxn6OU5LXX4PTkiJOjA5+uighZY8HB5qK56CUmqNqoq4i1ilPht4UObJ0QkeJDiC7YKMThOqzwXndpJVZYVFfMWgZnxtkQNlyfwfarFgfdmMnOlJd9aOIa0PoECAUhtlcIryhIF8MmwxSOdRecRTgbNsEuAR0ROkaI+BRE7OwQtLI1jVmEHc112Qp9gsnZNb5OafjrxKinM/VrA2D2GpzrzitC1mZ0lsbaJTHJJiQzh0QGr+0THYmyL/jjgVt1/KkALAYnfEEdJyxS2Fgd02uuwlMbAuOv94TiGiExhqlJPzG71/oxiaFnLjzPXhGw1mGMjyyJyVc+Hto+QTOE59QVrV/f4MK22m2oT8ynLwG8zwbdzW2yfMh8foxtSuq69g6stRhFJRUSiQrmlrGOqq5ZlRVlWVFUFauypGwqGttgXOMzyaRAJBLbStLcYRuJ9b4g0iwlTTPSMkEvC4pVhRTQSBEy0xTD4YhitUJnORdGU7Y2dtjc2mQ8mrCxueU9w6bh+OSIo4N9yqZhY2OT1rTMFw0vvfwStjWcHB+T5xlt3XLrwUOMM1RFSWsaHj18QFVV5FkKSFKlGA6HzKabpFnGcDjCWOfpgSRlPJqQ5kPSw5TlculBR/gQlcVy7heXsWxMZgyy55jONsjynHpYc3Sw7xNKnGO5XKEQKOkXZToYUa0KsnTAlUuXaEyLRLLaLJCmZTabcef2JzRVwWq1wFmBco421LaInJzqtCY/WXwcqQ8hw/V+b4dAOjAyTOxgQgXsjVOSYP/F5YtWAqzEiVDDodOY4wT1dyLDBP+rEKfbAVXUaELRGqX6/lyds0mGVF8VIxeCZhe4bRe15qjtC08B9Pn86xpYAHMhQ7ZjsCDWbqezS9Y1u/h73SlGr+VGzfesNiiCU6j/iIg1c3kSKELkQCxyZPvUZH9YsHVCzQoXNp7exNdAgpTerWVCau1k6zUuXv8W040Ztjxm78H7PNr7mLZZgTABxG2/sYc2Q5+ZIWeMp7Pabx9K5+e9EVFR6CMljPWbnhQ+KsQ5up5srD2HM1aLcF8KTP+9aLqD4YgkyZFSsZgfsVzMqesaBCSJB1xPaDuMdTTGUDU1q6qkKEsPuquCsiqp2gaLASnRIkE4iW0tzim0VCRakqUWJRStNWR5TVqmZFnKqV6wWhboOhTH0ZprV66QDsdMZptMN7aZbW4zm45J04zVcsnx4QGHR4esqhKtNUmasVguGI1GvPrKq1RlydHJnNF4Ql2X3L13l6qsWC5OWCwXgCBLE1579TWv2UtJW9VUdcNgMGA8GjLIUmSWY52jrSrKssS5CULC9pYhz3Na13J4cERT1z6srGlYrOY83t+jqitG4ynj8RQ722SxOMU5R53U3Lt/n6YsGY2GZFnO4dEBzrRcv3KdV996l83NTbaFz+QpyyW/+Vt/m5PTE8qyQChBU9dxyoQpRKfR9ht2jJnttYIIuK47to+nXCcpnHMo0a8BJwRKOlxouxLDkvwCj6nGAcSD5fxXofaCp16C00ioM4DbAW0AGCFUaN8TQ8WiJrTOZfaLLzaC7J5DZyr7UDRc0HiNDQDtEMJ0m9N6plRfS2BtcTsBToYuEOsA2vO2HbAGDRUXoiRitmCgOc4ARnhmPrxE9tcmcJxhTJyUAW4VTmqyyQ6bF17i0vW3mYw3cM5QVXPu33+A2VvxxvQFThvBDx+WvPut/y3fHUmO9+9wcnqX46MHHBzeYVUco7UmSxWniwOcLVDUIRLEdRZFlLNUS9jIY+q8C3TlGUolxCFbn+DinAi0Q6RJ4rwUMUgyJLjETViGTegs5bH+3L9Ingm6QijSTDNoh7RNzWq1pLXGd0RVGicF1liM9eUbm7qhKCuWhTeJV6sVq1VB2Ta0ziKU88HlaJxTePrR76xSOl8oJ82wWLImI01TBlmGTjRJqlgtS5qqIdEpw8GAuqzZ2trlwuWrDAYDXFNy8PgRH3/6MYvFAgsMBkMaYxAqwRnLZDxl7+DQUwV5xtHRIXfu3GE+n9OUBUprdi9f5de+8S6//p1vcXH3EkonrIoSqSQnp6fsP9rjwcMHlEUFzjDIUlyq2d7dZmtri52dbfIsZzSaoBJN29QcHR3xyc3bvPfzn3Pzk0+4e+8+q6LislCMRiNmsymtsxwfH5OmKRsbMx7cX/L48UOqoiLNUtq25fatT9k72OO73/0tppvblEWBMS03rj7HxUuXebz3iFVR4GIKdODLIrHbBRYFs25dY4ogGWqcEWnBMxGW0coVjhYRwDXwoPRplM4F0HZe45EhIqKnMP5qEAweFHuTXYaqXuvNJ4WSPnvsDOD6+NbYrLI/X1z8gS5wPa1zJvjfiVBLRPnaut3YOQhRDjFZdx103Rq4BqW2pwj8mXueV6yNsOitmY42itpv51WKYL4+PgGckV1hdyEkVkik0yAl2egCL735d1HTF9javsRiVbFvatLhgEpWPN77iBsHDyg/+iHPvfQGHxT7/Jv33+PKcy/z+vY3eO3695ivFmgBEwWzfMh4NORg9YBP7vyQP/iD/wem2fvMs/tsVpoh0i8IH6cbt8JeXfDJKf6ZqxCTH5SANc5dSoVzMXY5WIHBmRaHlycu/2Vn87ML3tQNKqT5KqXROiNLDQR1va4biqqirGp0IlhVJauiZFWsWCxXLJcrqjLEkEpASRKVomSKMwLvhJKBP7LoVAbN2p87yxJqk6IzQZoJsjxhtShxRiKFYJBnCJVRLBe01YpyOefuvbvcuX2bbDBgNtugbWqkVrRNzdbV6wghSBJNnuU8fvyI23dvc3J6QqoUl64/x7d+/dd59xvvooVk/+CAg0c/ZzKbUbc+1nY8GjEajnj33XdpW8P85BiBIM0zRtMZwjmqsqRclcyP7oKQjMcj8iTlrddf45033+DmrVt8//t/xIP797l37w6mabh0+TKz6ZSirDg+PEAqzXg8YTDIOdh7zN7eI29NVD4cr6wKXnvjXQRQFAWDNGFzYwslE7AlpvUzIQbir8+P6N+KCy7GIIhuYfogfBsPjtVI1r0wFl9Xw7nubSckSriu/qlwPlJBOSILh8WhEJ4H/isQMuacT+LwyluIRZaBMpAKoXw3YCX71utqDZQR8oxJv97qHNdXchH0IBEda/0il56nFIDU4CytsPQ1jCNAhgieTutd0379mcO3CiDqTAcOHe/ZacsBUDuuODwL98RmLIAQb+uE6L6zRIDSzK7/BtvPf5uf3Dmg3r8HP/8EoxOazR1GtBSH+4g7DxAPPuHRnZvwoz/hsUnZm+7y6NYjHl3YJZOWV196GSuG7M42GM22sDpjkmf8xjuvMj894Qd/9n9BYNa+Y//8wujjqwi5s9QshFA113HmDgHW4JCo4OHw3HJ4Hi5aHTHjdV3pWOOb/5I6w7NDxpqKtoWmaX3Kqk7I8yHGtFgL8+WKg+MTEiHJ8iGrsmRerFiuVixXS8qypm4NTnp+MskSMp2Ck7RtKHAtfK63lL7iV5Yl3omhJYnV5Gh0BmkiSRKNThLa0tdwqKqCk8U+QijyLKWuKh4+ekjrLKmU1E1D2zZMsjGXrlxlMp2SaE2uE/YfP+LTTz7l4Ggfnaa89dY7/PZv/TYbsyknR8ecnpywPJ1zOl/w4P4d9vb3aI0hzzIuXbrCCy+/zGA4omlaRqMxD+4/IMky3vv5T3l4/y7SwXiUk6QpO7uXuXjxCtONLZJEc/XiLv/x//yf8ic/+DP+9M/+lFt37rBYrdi5cJHRcEgiJccnxygUR8cHbGztsFgs2Xv4gKbxE+/WrU84OjogzwfkWU6eDSjrAmMsZePTtH1crohMQgDIaF76ReesN8e6DJ5AOfQmrOdnRUiqAOmLb1vA+ZRgHJ5aCAArRHSgcdYcFiCtXyAiFsD5FYs1BqeDpisjnRAJ7L71uhJ6jVLoefL4JT34hTbnbh38IC7qKBGchfNlMj2I+ap4wnXL21+nC9uLxkr/bHqQf7qIYJl0+nF4JrHm8VlLJ2rAodyqC8XEiQkOrh8XJ3BCk134NebjV/j5v/sE2xQ0xmCLgmw6Ynlwh8vbG+w9PiJbNYxwiMZweLzPYuMKs2REdu8jkg+/T6Uk//IPHPLiS+jLr7F57QVevrTJW5evsds6vvfd/4S7d3/Iw8d/HsZR9GMex6H7zmsBZU51CoUHz/gZ3/TAj7Xnd92Z+g8uOPMC8Lo+okMIX3Uv9sv7y8iz2/UIQV0XFEWBMwYpfHYaztE0Nafz0tdfsDAeNhhnKYqCYrmiLEqaxuDwKbJZphlkGanMaFtDQw3C180V2j9sqRRahVhICZnyRL1OPY2E9JzuwtRUVUlbOU6PD2mb1odc5UOM9ee0jUEOBcPRgI3NHXYvXGA0GDKdTPjo4494+Hif+eIUhOStt97iN7/3XebHB5weHVJXFffu3WN//zEPH9zn/r07VE0FUpHohDt3b/HjH/+A2cYm27tXyJKUk5NT7tz+iMFgyMl8wcnRAcMsZXt7C2PgYG+f8XjEtRsvIvRlpLN89zvfQSrF97//R+wdHFLWNVubW0ynEzY3ZwjhKKshi+WcCxcuMD89pTg+RGtJPhhQrhZUqxVHzrG5sYXINHVbE0OSbADSuCXHDEYbOFbRLdjIgYX5bEVPCYT3hXCeh8R7gSPHZjpqARw2hJ7ZUOouZBV2fGCoVRU+K9znwcXXJzZG5YRat53JGrU66Pqiee3Wv+072doOCP26tvTFYs6uSM8b+/nrXKh253rg6ArOBIkdQgw+46/TZc841dbpANddsrd819M0HKxtFsbZtePi/Z+lL6IIIVCh7KQPK1Sw8RJH+iL3P30PmRtm17ZRNmX7wjVyAaflPjsqZevqDU73L3Lww5Za1lS/9hxbb/4t2u//EelPf4IWFnv1VYaDCXZxyuatH/FnD37GnRuv8bPbd5gMcnYvXKKdvoh79KMQMfJZjbf7Gm6NphGmewo95WIjlwAOjLE4aehiteN5xdqG2gG3P5Gl23s+45f4Mn6KZ4KuCl7ttimxxgZOBxA+f7msGk5kQaISqtrTDvPFgsViQVmVWNeilCTRgiQUNldC07Yx2DsUIBfBUy+9NtEBcOr5NKl87YXWWMqypanB2JYszZifntJaC7YlUZqy8BW8NjY20EoynWxw/eo1BolmtVpxdHjEwcEBq8UpTV3z4gsv8r3vfJdsMMI5wSeffMQHP/8ZNz/5iNPTQ5qmxlgHUlK3BoSPyR2PxkidcnTyPlVToaVitVpy795tH9YmFU1TcHp6zM1bt1A6YToZc+XWTZ574SVeefkV6tbw/PXn2T845IP33uPhw4cURcly5TXisjY465hONjk63OPSxV2K1RJnLJn2GXRlVWOdZTwcsLNx0U8Ga7rl1mXoRxPU2i5Z0tu9PWXg51iHKl1JSSscWkQawh9piWUy6TQyaUMuk4gQ4wgWMVKcSdJcYyx/tWKdDcDb4FxKjGf1zRA97wd0ROg6LDobQbgvJdOXPnxCAjh7x5Uh9kKDoKlFJ1Fw4ogQ/RFNW+tcR7ue4Xg76ihoxUKTaIlKxuTDGXma01pHlg9o24ZyOaeol6yWB9AsfVEx50HehfEwzoSaHf6S0WLq7lckVJNrPDaG8UbN997cZkO1KNfwcSIp6pLvbU+5Oh2wNbtK08748fVtBuMJ+tJlPjwx1P/kH3Pj1RtkVrL/whu0THnw+BbDj3/GJXtK2j5i/+OfcqC3ubt8iZ2jW2gkKnxn283gNfAVcWuPG8damF7Hxfb0gAs8iw9DNSAS70yNj1v4Apb+GoZYgS5+Nl5pHWjdl1B/n63pOtFVxm+q0vNNQoWCNYo0H+BEwrJxNGYBpuF0fspitaBtmy6NUieSPMnRMun5FhlCU5ToSiUK580ri/OxkkohtMMKSdqmJJkhySpU4qMRcj3s0jPnqwJjY7C14fj4iAsXd9mYznw9iLrBtY6j40MOjg9ZLJdcuXSZV195lbqq+PjDX/D44UN+/vMf8+knH3J4fEJZ1ZhQ9UwKv3HkSYrRGmssqzJ2i2hIs9zXYDAtTd1QVRWtMV09CusgTVPuPXzIg0cPMcZycXeXyXTGc9eusff4EZ/ePObmrU+5WKzY3NymtY40SzGmZTLbZH/vMWmaohJNXZeB5vHhNmmagVAkWnvLOGyMHYZ2tJ3olKK4mXtzKr6wHtELsUeajeDaT+mwSGPLGQlxA+28yN1EwjnfPNERcV78ldB0Ab/B2PUuDE++34NcFxoVm0MK8MAcONwgT2o8Ds8dd+2qcF09BL++18P18dlh4Xkp58GlWVv0OOOL8quUyeQiG9vX2dp5nuefe4VksIkVOZM8IxsMuHm8YMMpNkYDVm2JpKWYP+b9j37Ixx9+n6PHH4NrOt6403c7bS9y9v4/ZniRB6s52WzBt68OeDddsf/4mMW8ZSYfcWk0QFU1B6e3KVcFD2zL269/lyYbMzcZm66iWsx5/u/9h4xmY2w5Z7E0LMdbzLKrvHucIE6PuLCzy9I2HA8XHD24z7oOv7YDBa2Wz763PvrRoRkzzdbmuwiT0gkTxj58WhAcbaHpV7jOOuD66dFbK3yJOf1sTte0vrKSTkEUNG2L1n7rTbMhg6GPXxXOUVRz6uWc+ekpVVXiMCiVkqbKx90mGUppbN0inUQJhVUWhA0xvn5PtVYiWpCx7IbQKJ9HQaIcSlVYW3IyPyXbGqOVBttgUFR1zcZsxoNHj3E6RSlN09S+l5ox7B8ccO/hfaq6ZjqeMptMON5/xO2P3me1WrC/v8fd+/eZLxbMi4JlWdJahxKKJJFUbUuharSQpEqjtHcOqZDVJqSiKkusbWlbS9U2vn5EiJet29ZrErc+pioWPP/cDba2LrB16TKz2ZTRcEDTNDzce0zdNIwnU0xo6lmWK4aTKYeH+yRac3x85NsopT4zLk09fzydzTBNS1EWoZ/Z+tSLc1J05q6fxyYovaEeQHSe4PqeakTQdf0CxCO5CJqriNxXyLH3DTd7LcNCVz/AOddHUvwqZR1UIh0SRETKwHlnme88ElN++5HtC+bIwJH3Gld0rBHbU8UQLQJFgQfcGFHQ35ZfD770ZqhzIbQff6EZzTa5cPFF3njtewym16mMoG4lRzj2Dyum1sCw5aPDO1xBYqYDPljVtI3j25Mh6eA6mzc2+cdv/D3u3/kRf/iH/y+WR5/6Fu1rzijRbbaeY7ZCs0qGFLZix84oVjn/+uiApmgwqxZrHJflBR7fe8AbL7zK6S/uc/H6G3xy8zb5eMy/SwTtdAO1m7Enjnh06z3Uwz0Gt+7w6uFjqFtuWcdOvoFOEiai4Z3xgD/TiqryPRLXjP3u4YknZvqZ4kPrj9r178davR1742JssPW1eEOMsQdT1Z9EhAiRaJV0e1OXp/lMeSboVlVFmiZonaB0hjErrGl9Pnqakg9HSKdp6pqqXFKUNctVQdu2SAVaQZII8jQjSTKcdbStDaUIvZEqpUMpiOaashIT9S8Xdg4niTGDntj3izdmxWjpPcy+qLdjczbDobAWGmuZTWc8uHePe48eUlYVOIuzDU1d8vHHv2C5OGW1WnF4cMjJfM6irKhby3A0RUpJG1oAZdLXgjDWUQtDagVaq67AS1NXvvCLcdSNwSIYDidkWUpV1xSrFauyClzSA9qm4fDogI3jQ6azbZwxpIm3IJarAodlMprQhtCVjdmEYnuHPNEsFifIwBGORyPGoxFOWja2N3AS9OkpWghQfmMwofMFws8tY/1m4EP+fLEaEQtJBR42hs3Q8cKRyOq5Wk8vRDKh5xJ9FMS6Fucz2GwsHAIoPrswvn45ew+us/JFyNCCaMTGLtNRzqbMhnA66bp/x7GLCRLORi03jLfozxNBf13C3ufjcK1D6QG7l1/j2ovfpdHbpOMRR2LAxwclQktu1w0PDwu+g+Tj1PJRlbBTW7ZmI77fFLgm4RUkHznDyWLFwGlWK0u7/Ta/+Q8u8LM/+L9x+9M/BVjbVMSZHylgZVeoVMOqxSiBKHMGUoOsQBpWyxPUKOf9o8fsbl/mka1pmxPM8W1+tnhInmVclUPKIuHw3gPmCj48OWBjMOVeecp4+zL3KNiYDrg03UIbRyYV1RlbRHSa55o2EX6tzdcwrl0EQhePzpkZ23/ah/v5xFCHdI5YQc5H+MheDbZeWXRx03VRtXi2PBN0T+cLtjY3fB+xNMe0jQ/BAhKtyJIURNK1xCjrmrppcDi0ksgEVCbJUk0ivSZqjK/644QPBJdaIpVAWGhNz5m5sPM45xvX9R5Vn36cpz5xYjIes1j6kC8jIEk0uxcvcbIoSLKMNEm5/+Aej/f2KKuS+ckJSSKZjAYsFicsjo94/Pgxy+WSZVVRNYaqaZBSMR6OWa4W5HnKcDTGNDVNVdE2DVmaEWsoKQ2thVQIamupGk9JaOm7TTjrsK0hH6SY1lC1BrsqcPuPKZua+XLJpcstUivMylCsTtFJwnK1whrfIihLBhSrOa+99DLL+QltXYKDLE2ZTmZkeU46HZDmAybbiq3dS2zPplzY3SXPU6+ZhoLdzgnauqEsC5arBav5gqIssSaYVwiqqqZYzKmLAmdaqrqlbsLzC5SJcc5PoKjZOnwb8aD1Rh4jNnS0IhzvokPtVw+6zq3dx5nFG9nMPjPtSQ66j8oQ3YLu8/K9mW6DdktXiW3dCRTDznra5qxRHP6jh0y3X0VfeYfZcJf3TysuTyfcv7eHShSvTnb4b+/f5ZHMeaNquLk746MkYxN4ezbiF7KkUAPeUTlbecLtumErH/LOxgbvHT3iqIIXJ1d58Vv/CY8f3WZVPKTveddnFkZ9MrWG1JQYkXB/r8AVFYnS5KnANBWjkSRNHIO0BY5wDx6TO0iF4teOj0lbhxWKj53DJSnOWN6++BxKaI7rkl0yWiUY0WCXh8yTkqI44gzCfu7UEZEHiSRJz+G6oAAI57ElhpI9+VzxCqHn0unSkgUORKw+EiMdBDGn+MxceoY8E3QPDg/Js5R8kKG1RicpTVvTtA25s74Bn/A7tzGGuvH2rEohyQRZpkhTjdTCv982XlN0nrgWylcYU0rS1i6YdwaCk8367R/nTFfMpWkMbes4KRdcvyy5cvUKt++0CBwyl+TDEVcvX+OiaXh8ckKeKO4/fszx4pTFfIFparQeMMpzlss5VVVS1TVVa2itpXUW6QwbwwGXd3doqiE37z8iSxLSJEEYyzDzJS2bpiZXGicktTGoRFOWBW6+xBYlubBcunqD3YHkp59+wmoxJ9VJ6CkGddlwIk8RQLk8BZnQNA3GNLSmZTSa0rQtGY4sEVx57gWyNOHToiDPcpx1qCTl8uUrSK3YmE55/bXXeXx6Sl3WXL96neevXuW569eYbGyQpElnShlraJqaxXzO4vSYsq7wUSkNTe35wuOTfY4P9lkcHzOfLzg+PWE+96GAFgfKopPQIBSfYVhVNVVV46xDZwnZcMRgMEQnCUmWkecD72Q0hmKx/MIJ+tVL4LiddybFWrJd99szNIJftL6WRb+YO8ANx7mgLTlrPY9rBc4anGt7IIj1GSLFAzgkNnSvi5zqxsbzpFe/zU+OLavH0Lg9duoln57ucWBL3smn/Ddyn08GCc+1msHFEfc3Er6TbfOaMfy5qUjHm7wlFLNW8INqwU6W85JM+fj4gNVgwKU09RX1Nq/yzd/4X/CHv//PwFc78aa8CAFs4QvnrkYkUzSKQZqwMiVNs8QW+CJVRtEkI+oS6ragXZXkSArTkMuEE1sxno4oT/a5MpqQZtOQeJLy1qWXEHrIMM+pmhPGiePxR39EbVZ+3Lp6vkFXXdso1+skeIkbXEzLFh0v79tVrUdwsAa+wWuxTve4SDX4d6XwVEcs0dkF6TwB4E+TZ4Lu4/1DRsOcbbXpnTNSonSCaSrawJNK4XwxHNNinEUliiRJSDJJNvAZZUooGmswrcHZBiENqBqpHFL7wfHe8FDTMzxgKUKaKoD1ZnDTtjRtS1nUNK0hSTWz6QzTVBgcSaJ83reByWjC4cmc45NjTk8XlFWoe2tSDg/38d0jKhrT0NjW0yhpTrl0XBtpdtp9PjpekWtI0gHCwcXLF9ja2kFpSbk4RThBUVbMF6eMpjOcEBzIB9TNPtu55bp7SLtSaGPItcIIzWCQgrUIawMAWubzU7LhFCmEpwKkpK5KBoMRzoaccSlom5qyKsiyAVordJrwygs3eHR4zGg0ZbixQWlv0wwd2WjMdDZjd/cSly5dZDgadXGKOGiahmK5pKl9soWxkqIoqOsS4aBqSk6PD3n08D4nR8ccHR+zf3jE6XyBk44klQwHGq0ItIqlqQ1lWaHSlK3tXba2LzCbbTHd2GI23SQfjDAOqrJmfnr8hRP0qxbRaSgQM77CXn9GQ+qcacRA+/7z3UFd8kPP30YrkE4LcmuHnjWBfdxsC1iSZMT04mtMdl7jzx5ZBm3Dw9UpddEwyCwfbV3i18eXmeD4ODP87vgKF5c1/5pjZqXjWlOzf3FMax1brmR3mfJ4J+PycMZsWdOsSpqLQ9g/ZOwyPnQVVzem2Be+wdX33+bRgx95eq/bWHotPitXJBNB5SSz2QZDDdoZpIVlNUdqTao0k8kUY2uyNKO1LU1r2BhuUBUnJK7l7WuvMtJTaid5sNxjZ7zFph6xbA35KKFta/bvv09T7AXe9uxzsz1J28Pl2nOje83x2VCuaMmctS9c/6Ez532SknDOIZ3fNK2gr6j3y0YvHB4dsTkdkGeawSBH4UIXVI2UYE2DEAprGpxtEdIhkxAelmtvFqcpOEXjGs9xSYtUFiEtSaJQCdjWEPOZRazvKnxlIi0CJIeVIBGMRyNeeeEVrly5ysP7D5gMhxyfNszGY5CKZVmyKhtOF3PqpvElF433zurEJ1/UZYGUAmMaEq1JtWUwnuDQTIZTlmlKbTQ2y9gaZ2xd2EVJyebWJrPpBm1rUBs7WGc5PDpgMBozGPuCN2ZVYa3gZHHMvTKjaGG2fRmlfZUmhKBcLShWS6QQtHVNWTUkA+cBtzXUtkZr3yyzKJeo0YSDY194SArJaDQBZ9i9cJEPPvmU0cYmR8dznHIoJJWtqdsaG3jdJPVFhPLU8+TWWto2ZTzMKYoyRFtYLlwQtK0v5VmVJcXONhubM44PDjg4OmHy6BFHJ8dYZ8gHCcNBila+doE1lrbxpS5nW5fY2txlOtlgsrnJ5uYu49EUrRK/cdYVZVV84QT9OsQFa8p2zq7oZwhAaftWRV0yQlc8m14DcnFBWpzpq4Z5wAbvnAwUjoshcz0dYW2DdZbhcBc7e4lby5z94weIuuWu8ckFs+mIX8wmPN/CQMG/nULapujS8KOdAdkANkTLZA737IqttOWqFIjJlH8130ccL/gHYsSjzQl//Ogh/+FkTDWvmUwVHJ2yMJZrz32DR/d/ihQhbXzN0e2QpCJFJwOSfMjJ8QHXNmYkEtqqZnsyxmBZNRVtWzLSGuFaaCsmgwnDdMAkn5HpBI1mkE6oEbwy22KQ5KzKkvF0gpENDx494Hh+N6z7oFniOuoq/tcDbYwsiRps5yILEvBFxGfmt0+LwNchDu45gT9/aEu/FhhGB/Au+JP8kySmUbvPAPvT5Zmgu1wVzOcL8kxhzIhUJ0ggTVK01sTUOmt9MRutJYYErX0SRZpmaJXSNDbO2zAgBqEEKvEZPwbTV1qSPR8Tc0tcqDiktWY6m7E5S1FOslwuyQYDmqpkN9tFSk0+HFDUNYvihKKuaaqSVbGkLgqk8uFuBsuqMiRKIqRmkA9BpWxtXUAISbFakeQ5k8mMi2nGcDAIGXkp08mE6cYGTd2QpylIwWA4xhjjnY5JToLkUlWwOD0h0T6/27Yty9UCrCXNcg6VxFiLkp7frOoGvVr51NNEQ20xxrKqCjbSKcVqichzpPUxyGmSMRrknK6WnK5KkuGUixdG5MOcyxd2OVktEYnCNA2P9vZZlQ15mjFMUpyzjIc5Kkko6wopJEoIBoOcfJiipKRtKsxgQD0akcQNdDhEpZp8MqRta4bDlMkgJdHesDOuxbaG4WDMZHaR0XiD4WjKdGOTyXiDPBv4521amqYJ/OavVqy1PobY+tRdazxV5gPlY6aa7GKSAV+HIbRA6hooniFj1+JoOxs1arQQuW7nTKzZ5YHags52UdvvcPNYoZ3jcbHkxuYWq3rJjUXNYuRQ21PeyHe5xQmNm/NmusUVoXiYVgxsy+XG8ng74z9fPMIcn/C/rDe5NVjx0+pTdt2YloQ/WH7AAsGSAX9iC+S9JdfShO1BwvDaa+TjC5TL/WBtSpxMSJIJs+3rbD73Lqt8h/tH98jkA+bzEzbSlFRpEuuQ1jLVGTodIIRAM2ZjmmAx5NkALRVFUSDyATbPGLQCYQ1aSbZ3d1hUh3z00R/y6PEHSFd1lkdXUhLotdSAF937YYzF2XF/qtkfOCIb07GDBUiIaoh/AnTdoSM4I9ceebB/XNwQni3PBN1VWVEWBWWRkCSOVickKkWnAxKl/E5oDKatAUuifbpkkjiSVIXsNbCtw/m8ApTEm6aJQiXeK+gcvhNw8Bh7jsyHLlmM70QsfAeGPBcMsymT4RQpNHsHh7QORnnGaDikaCyLVQHOURQFi/mcYrXywyJ9JlZVN6RaIWVC2xiU0oxURqIUs9kmzdRzqZPxJNy/QUof9zocT5BCkSiDbWqMNTjTMspzpPYt6Te3NrBHrnO0aSVp6gqZSKSFum18Wci2QTqfZo1SNKb1GXU6xdU+hdlaX35yY3MD5xwXLlwi1YphnnF8csTe0RFWaA6Pj1Eq4cqlHWaTERfGU1oE+w/2ufnxHbROmU1nCK0Y5BlpmviaEFmOUpKLu1ts7WySpRohHEkicS5HrpZMGPsCOgIaY3ASmrZhmGk2RhmJ8ok00UTOB2MGo03GwymD0ZjReEQ+zDpKxLSWpq6CJ/9XKzGV1lrni+RbQ2taEAIFXjuyEqTAhDxnF+bjk11s15ebsz0FEaM/uiAQYmypwLo2ALOEZJv71ZSHH3wCy4oDZ5nOtvnJyvBSOsNcH3I0TXmrsqyGKw52EgbUlO2SPx9t8a+Ob5FUBf8ze4Xk+Caz1V2GxQmaS6Ta8O7hTXaTTZpRQVLc5/lswnLqOCnv89bOS/zCrXit0owLw2tv/X2OVkeUbcNkPGNz6zqzzecx2ZiVU+Rty4G1fLz/iCs6Z9AaXFOTpgkJAmcEonZonTPIhzjAKMGqbhGiZTzZQanMF93PNJN8hpRw9/7Pee/Df03bzpHCdsDXK5GRABdBE/X1iCNYxmPWfJzhEdhey42BDyJugvLs+YV/7vFqPkplPS07Hr8G6JFd+GWjF6qypqorpJKkaQo4GlMjTLLGTxmMaXx5xiwDoVGJ8aUfhaY1vr2Ow4AwCGWRGnSqSbTyDwc8GY3zRaJxIEGGCshSCLI0AydplUbLFJ0kVEWFaQ2NE7SmZnPzEvXhnLZtWayWNHVJ3fjOvEraULxEUJUVapBDIkjyNBQoT8jSFOkco2xAlRiqasV4OMYZw6oquX79OZQUmLZkmOchIUGA9Vp6Y3zpx+FwRGsd+/uPmY5GlFXD6ckhaZoitPY8cll7vtY0frOR0re8Ae+gy3Lm82Nms02cFBRlyXgwBuf7k+X5gPsfvs/JsmA6mWIFVG3D0cmCPMsxtmY+X/Do4MBzqHXLPeVrVwwHQx8XPBlz8cIOL77wHDeev8polAIhSxBHWZUgLVqHWOt8QD4cMqgKdCMZ5prBMCVNlC8YY30Kt0wSBnlClidkWUqSSHQi0KlAKuFLAooE19ZfOEG/anHOYJ3sMtNM2/p056AyWbGWAiwlxgmc8nGevnW7PAu6cf2Hf/Sp1PEI0fO7ApwwGAG2HbFXDCjLmubhXcTGjM3nX+bK+AJHqmFrussH8pjV4Jh89jw1jvmDe2wlI142GT86/gWDg/cZlC1OnHIhEXzz+BHtfA56n4KWzeUJk+SA5fAeW3XDhfEmq7LikqmZqANkM+feYIe0KXj31e/xwstvc1JU5Crn+LQkyzMqUzFvG36+/4D70lE/f5Wbn/yM+cmcSZIyKhUbWY4UiuFQo6TCWIvUKUpqknTMIBuRJBmL6oTDxT3cvOFAag4OPuJw/ybONR2QGtHrldL5xKc4lpFndutgS/w7mPw8yfG6jmY4w9h2XHCMNY/A6ykV0Z2zp5XifXi8j863XzJ6oQhZVcPxlM2tXZyDoljRtLV3tgBt29Aag9IJOT7rCOWrh7XG0dS+wWRrTeAzJYlMUSpDCB0ynRzKV9sNVd0lWkqksjjpi6QYfFNKJWTo1QZZlvrCOEmKkYKD04L9o2OqqkRIRZoM0LrCWkNrBFIp7/zTCSrLcc759GMlfEHxJKdpG0g0zhrSJGF5espwMuXFF6+TZRmplly8eNWb5EnCalWSao0JzRabpube/YfkWcLbb73Dp59+TNOU7Oxe5OjoENs2pGnKMBvQtpXvLqFK6tYXh7etwTl/HiEly9WSra1tkizzhL2E8WTMzfu3ufP4sS+AE7jqhZQo50OT0jShrArqqqIxPuYW68BYr8EZw2iQs3Nhm42tLYyFVVF5AE0SGmtobes7YLQGKWToCp0gtfL5FDH0Jkw+KVRghxxVtUIoidASNFjluXmhNG0w4du2BSZfOEm/aomcrud1W19Q37W0ik6TVUqFaOMGF8LInJNIpZD0gfPrjpe1K/CZtShEF+ts7YC7i5x7J4fU1iIHI+rJhMt1w8fukMtzRbtdYGaSrXJO4k750LbsHX9CaVOW8iLfomG6d4idlwh7SJmnpMWK3DrUwLCoC8YWUluzfzQnFRqhLfPqhJnIeLxasaUzHspjruxcZGUMd5Yn5ElO62rEQFMIy0IIjqxhkRsuXB6x+uQXFM0pj8oSnMZqSd2UbI6GmOWCtG4Yz2YkQqB1xmg4xmK5df9H3Ln159TVCVLYro6BEC0IT99Ep6UV1ndCJpIAUa2MESB4uqfjA9aoh7DBCSnPACudU3QtBMXJ0MbKf7bndOMBfZHT6EBbf9T/XurpFmVNbb1JvbO9i1KaxWrJ0dGeT3UtCxpfQ5AkzVHa0pgGY2ts6ydVXbbUja+3a4RnaaVKUFbRtgrb+qIjONW1dvF1BRVu7Ysa48jSIanIyZKcPMs5WZSMJxPfh6woOTw+xVqDTlPKw0NWZYmUkrqq/WCGKItsMEAL39VBJSnDRGNag00Fo8nUZ1JJh7SOKy+8wHA0pq4qNqcTNre2yPMBB/v7bI6GaJXhbMvR8RGTydjH81q4d+8e88WCy7uXuXf/Nndv3WQ0HpMNRwiLT9cl5+T0kEQnPvEJnzadCkFRtORpRmssVVEyGY4ZD3wTzJ89usfD/X1c4MGKcsXpqQbbhlTsY5ahvKZUSUiPhiz3PeSWqyUbzSaD0YCDgwPyPGM0SNjamKCEoKprX1yobamahrqpcc5z6oPBkDRLoJFkSqFixVInu9A+Zy2tsWFN+AiUqq0QhcbiMx0b02KM482LF7/URP2qxIVWOs5aMAZEiwkLWTlPSUmhcM6n46K9FSuV6njYGKcc9V2fWLF+jfUrei4wXtc6wckyY+/ePlpANpmRDjKSyy8yMg133Zxr117g29MZBwefUhZjLsiCkgP00TGDylDXh+hMsVNWVA4GWtI4Q641ozTHOoPWmnGSs2oqdJKSKM3hfBla7KxYNQ3ZZINEaxYDzYlxXMJgEsfCNMwlGAeFMzTKcFUOaG4dc3vvLm21ZDqc4IBVVaGzDONAW4dMPRUlU4EQhk/v/ZTHDz5gtXyAFLF4voqjgk+ZEfRJDKarBtaDpM/yk/iEGxdjiQOqemBei0xYj7PuVN9Q0S28JxGkImeazBhnAwrTcuXSq9zfu83e/A4mnNFbLr1TrWeQ1qMbni3PBN1FUbJYVVghGQwnjEZjhuMpQjqODvYpFgvffFGl6MTHjdIo2qqlrVuapqUuW19VzFpqGlQikVJ7LUgInIG2AtPg61gCCEVrHaKVSC1J1BASQ7MyNNKSDxKqxpBoDbbEGUPbNJwuF6xWS1bFCtM2OOdo21D/NwnFdKxjkOcM85y2LskSjTWGuq19EohS7OxeYDAY+ZYsSlJWFdeuX+fCzg5ZlpElOcIJssGAg4NDnGnY2blAlmU4JNNNyCczHj24y6effMJ0tsFwOGZVLjFNgzEW6Vps8Pj7FjAW43w7n7qu0Gnizdm6wgCVMRR1jTU1n967x2KxIEk1w8EQqVOcaXHWsFgsfWIKvoLtqlj55EQVdnqp0Er5YkSpDzmbTidIKamaFmOCqWQ8UCsl0Er5akzWF6FXQvm4bZWitfQhY8JB43w8tqkQOkElmqZpEGWBbVYYLMa6wJuGfPZfsURnl8/Oa7BC4WsphMXofN83YS3WSRSe83b4sSQUX5FnCF3oNSIvPX8Yr+t55LrN2DssObUtzYXLTGzL6eUp2/UJD56fYnFM8po/Pr7Hezd/wI5IWSWXeXMg2VwZ6rpGY7FtSoLCKUjyAauq9JSgktRNS5ZlnBZLJJJEKsqiRCnVW1XGMj8+xA0yDu8UpNc1+acfcvnaZabTMQMpybTipFhx8+iQD+7d4Rfv/RRz2iIayWySY+qKjfGQcT6icYbxYEI6GqOzjNPFPo8+ep9i9QjhWmL7nI5D7Uasj16KoOrhNXKlrqcGugQO153HiwyarFesuufREbzrD8Vrz5qEidtgZ7HF1cEVnn/9Hd54/Xc4Oj3g8eIWP7n1Az6++1NOy4NOo+2covGkImrfz5Zngu58VXJ0uuB0vqRuDRtJgk4TWrND27YslwsaYximmiRJsBbfVdcKTGNpKktVttStoTKWFkitLwxtXEiVtGBqsI0jEb7ldayFaYx33OAMwmXoVDDKhzR1y2q1Ylka6rKkKFfUVYltK5QIZfGU8AukbVBKoVWCMS1pmqCE8rGuWvlAfoFvN5NoX7TdeV5TZimmMbz44otsbG1TlBV37n7IN955lwu7F6hrHyonpWBzcwvhHPfv3+Gn773Pq2++yyuvvs5kNOYnP/ohSZow1VOcc5TFCmlbsDXpbIpWKaerJfvHx6hEgZG+lGbQUtu2RauEqmlItUZrz6nXVYPWLalQNNZyfHSEcY6iLJBChpC9HJRGJRotlW8tZGqqpmL/4JDZ1oyDowNGo4zRMEVq5UHItRRVTVN7+qhpDXVdUZQFprVIodFK+xrHChpT+8I+raWuCqxYYX07QqzPPMBhcaFFiu/QkHzhBP3qxa0Br8HYlnVt1Hf7je3NY1Frh1COvvuALwvoNTR/1nUHzll6weKsL1RkGseDe0fszyVKD5hoxfZ4k/unK25sbCMPlqysQ5t9lvUxN8qaTddQuvvIIueySjiSoJxGpWOEqEiVxUpH4yrqqvI0j1bYVjBMt2nqitpVJFJTt2at5oMjTxQ1LRQtd+7dpEkU9/ZSODyksS2HbUMiFZ88vsfh3Vu4Zc2mTLkw3WCSjEiHGwykZpiP0VlKPpxhbMuDR58i6oLNrUts716lahoUEhRY4euKWFtj2pK2KTFthe+8YcBV0dj3eCF82F3Horvo4IqFyOOYi7Wfnmro2QEXUFOS6ZwLg8uIA8ntn93k8jev8daN32R38yKb04s8797g19/4BzxaPOL9T3/A+7f/nI/vvEfZLmht4yvmddX6fsnohbqoOTg84cHDRxwcHzKdThjkAwb5iPFog3xwTNOcIpSvCIZztG1DXfmspqa21LWlrBtK09I6ME7RBs3LJ7Q5XOsHwIeR+c69QiusVCidAQJnJbPpBoM0w+ahNdDymKosaZraa1yh/KKwhtFghFkWSATJYEhVlmjlHT5t24b26RYtNUprMIaTkxNPaEiJThKEabl06Qqb2xcQUvHxRz/j+3/4+6TS8fLLbzCaboJQDEZDtE65d/NDfvbez/jhj37EzoVdpqMhOxd2eefdb3Dz5i0c8OjBPaqmwlQVTbFAKcWNq9fJByOsccyrEpPGZygYDoZYYxDWkaUZdbViMp3S1hXz5QJnW4yRWActPlRPAFVoA9/kBqkV1vpymWmWU2cpxjlq51CDpMs6XKzmJFozHGRgvYP0dHFCUzUYA2VZYeqaVEmsUygl6Xks77dtQ21apMDYxreyb1t0mvrCSVL6UpwOpMq+cIJ+1RK1lah5SmsRnn3GOV9KULqQChycXzGP34cYhdrCUnC28lh3he7HuZBEZFqvWbcaSJlujamtQg8SjjfHHLSPONqCW0f3ECePaQfX+GY25DiZUtYlY61ogUwmZFpRA7V2LE4esFo+pioXISoixARbr/VVgyuMtl7EOENdl0jjNXgppc+YaxxSaoZas1gteHTrE+zjB5SupHEt1gmUM9jlAn16zJVsgBKKncEO1iZolTMajhEqIR1t8J03vsUgGVG3lnyQYxsfIeKkAiUREjQWrR2pcBR1yXFxymJ5StMWnM4PeHzwKXtHd6lXh1TLfdp2ieo0XNNFFMTfHbhy1lkWEyRcUPakVQjn2y5d27jBc8Mb3Lz9MZvjbd546y2Ko0c8aAzJYILQiiRJ2ZC7/Nbr/xG/9eY/QiSGRXXKg8N7fHjzp7z/6Y+4vfcBjW2+cM49E3SNMewfnnLnzgMePv+QjekEubUNQqCThNF44s1HfLxj3ZSUxcJ751tfb6BuLXXjqBtHKzRWaGqjsICWAikcykEC1MrgWsgGOY0T1I3DVA3DwZCN8ZgsSfG1GBwnp3NM23A6P6GuKwZZTl1WtG3NxtYWq7LmdLFE+UZdaCnRynfEjRWIdJJ7Z6ATVGVJTPUbj6c+lCrNuHDhgq+0lmZs716mLBv+6//Pf8XLL/yMd7/5G6SDEcPpBj/5yZ/zb//Nv+TT27e4cOEKo+EYKTV1XTGbbXH5cs3B3gFbm5t88Iv3KIslxhmcMRydnDCZTNnc2qHF+SgGa7tiG1ZJVqulDxuzluVySZImDBnTNBXQ+GprztLWNVpKquAc8t020q7MZGtbhNOUTcmgHbO3t49ra/YO9tiabTIc+BAyrSQCy3CQ+LZJTUvbNGB9bKlvxOjDqqXUKGsx+JKfWgxASqROEVKjtSZPc5IkBSFoTUgF1+kXTtCvS2y4fyEM0nlvtbMOlF+4Ukofy2ui1tX/dB1/xboqtS4hyse23lEXMtUeH5xy76gmHRuy0QajxSn1bsYVI5ksTtiZ75O3LbI6QTYlz+U5hUopG8NJWzNKRqSDhKODT3n44D6YonMCeYeQ70bs6U3LYnkXNrYRF19DHD5AncyR1iEDONu2BY+HjIWkWp1Srw7JJUwFaCHQQlA3JSbJGEpJmo6pjCHPErJ0xKpyGAfXxtt8eOeUwcyxNdL85IM9SHOsUpDk6NZ3N9nZ2QRlGSrFUE64tHWRcsNSCMlO63jVVZi2AVlxfHiHj+78GQePfs7+g/cwzRLpGtZqhXklIHC1MfpARK1WxDaamlm2yTde+Q6z0YTbH3/E7Z/f5O5Hd/lb3/ldbrz6NheuXuP4YMHR/h5H+4eUVUuW5Yw2Zpwcz3n97dfZ3b7M1eeu8J0b38X8XcNPP/w+P/z5H3/hXPuCerqwWpbsHR1yeLDH0cGG79qbZUjhyPMBo9GIqiho6pKiWFE1jfd6O99+J02gbjzfoWUKTmNaH3LRCoFSXoMQ0pBlGQIoS8N0Y4dpmmIdOGsZD6cMswTbNuwvT6mqmuViSVP56ISDwwMkgmw4JhuMOF0W2LYlSVLa1pJoTVX65pKTLCdNNYPhkHJVIGzLZOTTUwe5D+DXOuXq1SukaYbSCp3mzKYzXnn1NX784z/hj3/wfX7+/s/59e/9Np9+OuXmxx9w9/4dRqMxb771Dju7lxgMPS8s8pxd6esd7O3fJ8sHLFZLQDEcjTB1Rd00zJdLGmupKk8PJGlKolIa68iyzNd1sJ7GP53P0crX9S3qFVJI2ralbRuckGipGY5HHryt9RzsYMBgOPTFeZIMLRSmaNirDjjaP2I2nTKZTJBCMBrmTIYZB0JgjfHWAI5U+roYWkITsn98PRdB04ZOq0L5CS5SnFM+JMs4rAqlEY0I1Q3UM6ff1yF9U0dPMZhQ9Ec6QGpMLHsZ1VfjSRMj14HXIpyh7xC7HsYUYtltjYn1lY3BGEu1bNmabJENhhwoR3JhSrEqeby34LXdGb852OVEnpIDVita48iURqaKFQmn7RHHDz+hqU49RxrTkMN1hZCxWmEAHcPpg/fQwyluNCNflaQYVONrX+NCjWMnwBk0Di196VJCVYih0iyQDMZDFmVJayxapxzNVxwfHDJfWra3rnH/4GdMLl1D33PgWu6ZAat8QG4kRVVxdfMC1UDTti07dc12lvPGzg4fFcfUCLZ1zq4QPDICp1NyPSDfnPHbW2+wNbb89NM/5s9/9q94cOsHUO37+45NIdYSI2ImoPfLCYSTfOPF7/JPfut/zQtX3+Kjj/8cvUy5e3KLvfyAy1eu+3htB5PtDYqy4O7jfZzOub69g8pSRqOUk72H2KYkzRXL4yMSpbkoLvIf/+b/5gvn3LNBF9/2pSx9Ue6yWFGsFviGd4JUK/J8QNPUFIsVxrYonTEcpbR1Q1U1SOVbg/iOv779jgutXxIhkcJ3pBhkGh00qPFogtYpxvpuvsMsIUlSkkRTNA1t1VJXFUfHxxjThmpcLWk+ZJRmHojbhiRNAYFQjqpY0TQNmUyRSUKiE4T0/KXvvrtJW3uHX2tati/uMN3cRAiNCt7eCxcv863v/CZCOO7d+ZRiueDg0X0uX8/I0owrl5/j5Vff5PW3vsFwPKMxrQ9Ta1qKoiTLfGGRuq7Z3PQdg4U1mKZiVayYr1Y0rY/0SHRCNhyymM9JdIZA0Lbe4Tefn1IWHph1lnRJKon2baWTNCMPccQ68eF1zhpM7bBpghSKVGgSBOPhBGMNxeqEx+UeZVmRDXOWZcF8pUgTyWw8oaxq2saSJ0lo26TAGNpW0iTeyVbVLUjjnWhCIYzCSGhrSx0aNboQCyulQn8JT+9XLb5rgK++5guZ+3Y7Thpf01lKn6WG6boE2xDpENvSO+dwyiKM7RtWduIw1lMKEXQ9JeRYtZ5/LVyLujBFi5L69JSRPaVaDdid7XBpnFBbQ1m3nNa1t7pGA6rVXQ4efYSjCREAffREvKfoJIp8iNfzDM3NH5Nce5tyOqNZzhkgUK1ByRB41bYg/MbqWosOsbKtbamdoG4N7XyBQ3Lv/mOWx0sOVi0m3WBn5wqPi4Kj4yVj56gTzVJn5KqmPjlkcuESR5szjnNN0tYM5oKpVvxh1fCT40N205Q3BwPmbcFcJ9xtW2RhectmzHTKp5VhmebcuPG7vHjtN/jg9h/yB3/wf6d4/AugxuEI4f1n0hT8vuPIRMI3rn+b3fwag2TKpa3nKKb7fHTwU65dvsbLr79OpjXHd++QDAY0xZy2XFG0JbfbhrffeZOXXn+JpqpIB0Py8dAnWOHAGZrlFxdxenYLdmeRjr6qvgPTGspi5bs6CHw8rfAFr7MsZzjMcE5SlQUHh4dQN+jE987Sia+eZB0IKcjSEIdiBUJL0iRlOBxT1r4urlA+xOhkWZDIyvfdshaDoLU+hKkoln4St43f7a2jqkusM/jSlxLX1LRtg9KC8XDUZ0I5H+ubZZmPqJC+bGGWJiglqYsShGa1WDKabjDZ3OKVV99gc3OT+3dvUsxPGU/GPHhwj+2dXd5889d4/sWX2Ni6wNHxMfPTI7SS3Ll9i9V8zs7uDjrNcFKRqJTxYIhwlqbVzBdzqrZGKt8ZQmtNXVaAYLGcszscBN7Ra15ta1AabFX6hWIsQqYkIW05y3MPJkiyPFSJ0z45omoboKUoVkipSbKMwXAT57zD82h/D2NbRnnGcJBxMJ/7TJy2ZZCkpFqTpQn1MGeQ+mLuOOeLxTsLSctwMEYbQ9uCcDVtImgbvznQep5Z/uqzgIk1UG1s3NuleXqNTwrRh75F3xngGm+yOuv5cmstUpquSHt3fsAZ3w4ohtM524KFPEkQaUKrBROnaecVr+VD3CAhV5K5qZiJBGUsI51jtaJKJUfzO5w8/kWgL2NV4r7wuHMCG2oHICVK56TpiOFwxniyzWiyxfbFF0gnu7x3+xZ7dz9hcbKPrlvfs8y2IFpa1yKVpDqpGCSZ75otJUdHxxwdntAsS45OFth0THr5OrMLF3CTjFdvvMqDxjBXKcY2YBytzimFoEkkZbMiH6SkCB65hsfSMpyM+M44597eY/7UbTAbTbmg/QanheBoWbM/liwEHB8seXmU8dxkzBsv/x1ms6v8y3/xf+bw3p8SwsR9LeRYCYwYwQDP797gxuW3KU4XrNI9xKLg05//lEcP7nH98gvoVJGOx6yWFcuyYTCe8U/+V/+UZDjGlDU61RSrJXnq12PbWDYuXaStSoQ1DIdf7Kd4Juha5zDOhnKDIVXS+LTFpnEolQZeT5LmGVk2YpBPfPPI5YJluaRqfFk3ZS1Kx1YG3izN0hQagbGSPEsZZAOkhCxVtLamaSvKcoFzimGWg3OY1tJaGE9nrFYrjk+OkVIxGOaMphNfIyGRuKWvtC+lwAR6Yzgak2Spd5iE0CkRErarsvCRFziuXL7KIB8ilWI0mjAYTfym0zSk6YBrz7/A1vYWTVnQtg3Xb7zk6++OZyTZgLJYkSeS8cVd5vM5F3cvkj3/PErC5t0d7t9/SNtWmDYnSfzGIqUGa0iHGauyIBmMmRcr8iQNITTe9FsuloyGE8pVASF2MEl8LHOe5iTZAIAmRGVopT3/qjzQC6EZZClCKVrTslrOGThDkma0GBrbcHx6Qu0Mtx8X5JkiTVPP58nEx+omCZPBkNEgZZSnpEkSzFNJ66zfUAcVeT70zr/GoVWFlj4tHGu7WNdftfhi4lHbteG1oCcJr9F2FrdfzTjnfJv21juphPXJHp/RcqNPx7Y+HM36TsEy+A5QUFBTDzLacoUzhrd2nmNDCxbWF8TfX56C9ZtnqRNe+uZvs3t4nf0Lz/kEjqakqku0ytBSB3/LgPFo08/dwZDxaIPRcAYixTjffqu1lseLFbtX3mClt7EnJxQH96nmezSrQ473HlKc7FEuTilKH5ZZLpYIJWgThcuHKDUg2blAmWnajZxyOmAwm/DDB7+gHG8y3b5Cnoxoa8f+cIaYjnllmHPr8WNOhinHGxd4cZgx2XvAe/WcH5KycfUadrXi/aNj3pjlvJONec9ULMaKadugmgpnU+7sL1lISWots8Er/O3f+9/zz/+b/wPF4U8RznYxemdC9ZxjY7jJ1uwiW9NtX+VPNjR1y5WLL/Pbv/sPgIzl6ZLT+YLTk1PSJKM2cOn55xhORmBa9vcfkE42UNkALXwAwerkkL3bn6Ck4uIb33jmnHsm6LpgDlZFyXyxpKwK2naE1pKqKlCqDi1eHHk+ZDiZMB7McMb68KxEI2SLki1WWpAmFFfRSKUY5AKZDzGNIdUDihBbqHSOaVrybIATAtP67KWqNpiQRTYZj5kPh2xubaAQ1I3xMbBSYWvnIyoC2EqpPYdsHEIlSNEyyDOcgzzNqYoCKzUoxcZ0xo0XbjDb2mZ+csp8foKQkjTLUSqhbStoHanOyGfD4EhSOKzfEJoGrRRKZrSN72qlE01RFswmE15+8SVu37xFtZojXMl8EQHI0y/GGNq6oixX1EVBqjUitOgGqMrKa/HKg/Qgz9GJZDqeMhyM0CrFOkPTVFR1HXZ9g20qGmdphEYlCUKnDPIBeZ57p5mEtm6xQuCcYl74MMFl1SBEQWtayqZikPg+cYMsYzIcMEwzEp36RAmlcMLXmlDah5OlWUae5qQqQeuUTGvvvDStT/P+FYuzFickUlqsFb4sqPX5/Bbr45+dxWJ9hI7UkQH2IXBOIpzvDSel6jKe+pBQX67R2hZnLV3jTufIpE+RHmRDpM5IBynHpmAoMzZVwqJeIcPzr1qDvHKF5156l8lLma99IaBsG9o2ZG8pHWKtnQ+RdC0E62m/KDDWz7NlueK0LVhaweP5HCtT7rUWpQYsKoE2irIy3L91D0OLHCS4LCXdvUGSJrQ0ZBcuMdm8wpSEe3c/QG3lyCtDXrz+Cvc/ucn9rKTadrx6+TmerzL+s49/RJte4OboGt98920OHt7nQ3PEfpmxeWGLF23FB6Zkv3X8p9vbZIM57+n/P3N/9qNbmqX3Yb932OM3xnjmnLNyqKypm91NsqluiqMIWgJpG4ZFwJBgG4btG/8NvjDgW8mAL3xj+Mo2BJq2BZswCZlSswc2m11d3V1TjmceYv6mPb2jL94dkVmkVElIpqp34WRWRpw8GV/E/tZe71rP83sk2zLya8WMV+sNJx4+Kme0WtHESBYjh1KyNo7p/vv80m/8T/ndf/i/Jnbn6TT9MzKugJY5R4u7SB+TVh7B5ek556eXfPTtX+POOx/Q7RqGwXN4dMi9+/eJUrFZXfLsp3/C/uE+IcDlyQnZpqXa26NZb3j68Aseff4pClgu9/iNr7nnvqbopr90Xc96taVpOuZzg/eSvhsI3qVlTpSoqiDPC7I8x/uA0hKl04t1zmCjIYokrhe6IJJjhhatBZmuCUCeZ3R9i9YBqQt2Y+4YCGxnaPqWPMvwzrPbbMi1YrlYsl5vsdESfCCTCaTjW4/xDiVyfEiLoGuCVFVOKOuaoe8w1jEYS1UXLPb2+ejDb7J/cMR6vRnno1nKfIuRoohEqZEijkdFhS6KJEERMuV2Cp26Zmtp2h3GWoqiHE8Jgft37/Gbv/mb/MkPvk+3u8KanoCgnC1YNy/xNnV/fdcm0TqzBBJSKXlDZ4rNtsE5Q64Vk6qkrmrq6YzJbJ/FYp9JkVNkis12w4uXT2j6Hh+v0ywAH4nqOkYmmVuUkJR5SWM6ZpMJjTdcNMl56L0lzwqcs6w3G6RMtthMa4qsIFdZQvXpjExpcpkMMJlOXZVQSeuaKZVsxkIRSHlxv+grxJRfl04/Mcmr5PW4IGUWEyMifDlbiDeG1FEhEMQNEOlG4n+tbCDcWIxvEprHeavOJBvnMduG918/ZF6UGDNgYmC13qZoLCFBSFrnGXJJ1JEBCDHj2WDIVUGWwzDGMVk0RkDbGwoBRmq6waJFxpBLnAs0UvCw61mZlr4z7LqeRQGxNURlePbqc/rtCfLeATpCzCPTBw9QB3eZzo+4XeV0IXBuOlw955c/+IDHTx9z2nb8/ukjvvfht7ltO340nLKzO/Tt2/yV6j3+1G35xjzjf3h7j0fLnP/j5Rd8a3nEPV3zvir5v5w+Yp0rfiQ8f/n2LZqzZzwzntej51eOjvjnfcN5VnBXKHxrWCpJpQXng8MEwWt3/xyP3/sbPPvj/wSiQ8WbqQICwVu33uPNw/foW4OQLcH2/OCf/yGT5V0G6zG94c6bb6CkRIRAu16xvnhGWdesTp7zkz/6fQav+dav/DpOZ1ydXyCV4Oj+HQ7u3WY6m2HN8LX33NeoF9JX3Q+Gy9Wa1XrDcrGgKgucg34Y8HaDzkvmZY2SacMdgyM4l9JxnaHpNtjgEEKQZSUiFuS5JIScGBMEwxiLDREfItEp7GDGIpMjhSD4QHCB89UF1lsmucY6S9sOaJ2jnUOpjNl8ihksbbsbt7dpjqxVRj/0OO+ZziZkUuOEoOkH8rygnkz5zne+x3e++12EkFiXDBi77TahLJWk70NaQpUFWunUnSqJHd8c1hqctVg74IxDS4VFsdlsAJhOasqq4qOPvsmDBw/4g9//Zzx58gUX5+eIvKCeLxgGS1ZUrNcrJvUkucFkEt6HURKmSPL92WxGWaQZblVOktNuMmG5dwuCZbo8pCgrHj95iLEGN2qThUxuNWsGRvs/8+mEYB06JJTf4XwP5x3rtmG9W9OZngzJpKwZrMVaR2cs0CJJOu1MSKQUZKRE4mR0GQXtIi04rt8EgXSK+oVf19Zzxg5XinHkcE1vHRdSPoyLKTt2twoV5Rg79dU56rVMKUHn4brghnHmel14QarIYlox21uSF5plNaHIS7p2h1ASdEEgkbmsc1xuNvzR9oS/cvsdWi/ICoENsBksOktfQw84JXC6ZN0PnDnLNK/Y2g43dFxEz8N2zXRSMs0kPTtCt+LThz8mRsuh71EVVNUhLgZcXXLv/husY+DqcEm89YB/5/XvsF8W/Hj9gmebFW/pA0JWcbl9gleez7an/O17H/IHr9b882HDD8+f8L988E2+ePqIL4aBh7bnw+U+/6MYuLI9Jg7o+Zy/sDflPBiEshwXkf/w7h1+oFcgSjKh+SVy/rBpMDLjN/aWnGHJUNQYQm9QquYbH/27PPvi94ibhwlyPp44pMj45uu/xrvv/hp1UVMUJSfPr7j71kf85t/5e9i+ZbaYM1nMMd2AG0zStNue3fqcV5dn/PjRI4Seoj//DBE8V6tzXj57ysX5KafnZwSga1v+6n//3/+5t9zXFN3kcQ7WcXm54uzsgr3FHkLIm/DFvuuRxlNNbcoC8+mIbU1KdnA20ncDvR3QWckw7IhTTZbNkWICsaZpHX1v6I2BCMakLtrFgLfblJ0WHFpKmt2WvmvYiMjQdSitqMuSg+UiJeACZ1fnaKESYCd4iizHYhn6QJ5lKCkY7IB1ntl8yt5yn7fffoePvvURQgi6kWub5wVlVdH3A5v1mr7vyfKcqqoRpEj1KBVm6MmzHO8sfZ9SNayxCQwjVdr0I9jtdjhrmM1nHB0e8df+5t/it3/rP+f3L38ba11SKcicrt2htQYhcd5R1zVd34yRL4zyO5n0zUoxn80o6xnT6ZTFfJnmv0qhdc7+wW36oefs/JRuGMb5sUCLJIuxpifLNO1gCc4ke7Mel6QIZIhJWhYcQQqsMWluOy7pXEzKBeMHhjF0UQTx5ULqK1HijAUs/S0S/wx0uteRmtfSsRACUiXcigwJ3CSu/3e9qCJ1u4GEHxUifU/HM+0Y5Z1AyWLM2vqZ8PpxyJgry2Ask6zk1mIPN3h2bUuzXhODBSkQo307hki4XPHPPvmE7x7c4f4IjgmywEjBxiUEqsoCUilsb1B5yXvFnM8uLnkqDKpW+GHgncM9fvDspyjvKFROZs+ZHCv60xWb6Fi89jar1QVWtMSDBfmDN7ldZHRFYFbl2N2aHz07SH8CmAAAd+JJREFUpfEtt32kxjHbnPGG6VFSco8r3LNP2DNbyhyOswV10zDPC2bzCc/6nsHCm/UBf7B9xZ/6DX94ZvmfLe7yn66e8Qf9JZ97y39wcJu7W0cnDFK3fG9vRphKoiwIESZ95NGw5UNdEaYlMXpu8xYP3vm3ePr9ZwTsjYLjYHaPb7z55yirKcN2DdFiTcdiuWT/9jG7i3NC8EgixShNNTbQdD2fffIFbQ/3XnuXjz/7jP/H//P/zrSqmBQlR8fHXDUNT05eESOJW/I1188fLwBEgfeB1WbLyekFe8s5WguKPEfLjDyrCDLdVsE6vLAYM4xRPgqtSkLQrNcrsixy5/YbTOvDZKkMAqXSvFYC3jr6oU/SmiDGhAHDMPQwFv/NdoU1ye67nM9YzNKSq+87RIzsNltsP6R49BBHNYJE6YIQ0w3pYkQjEwOgM8xfW/Arv/bncUPPersdQTkKJJyenBBjZOj6xEZwjihTKqoeN//d0DOpJigBza6hKNNoJNcZMs/HLDnJbDpJxZQE+bl9fMi7H3zAH/3x99lsG4IUaKkp8gJbFHjvk6vMjkdH70Cm8YP3kd12S5FltF1PVswQIsMMA5nzydYcE+Tm4PA2u2aLMeZGNO+ReGuRKkvfp+CxLhC8Q/hkIb6z2E96UmfxIdANPc5b3MhQkJDoTeF6/p+SnpNm8logGrjGlMSx2/uS7fSLn+kCXxobxq43hkgUgShTh8o1jyFGog/j99CPsejwpS73WrQlxmUO3BRa8S8VXQFRGozdYr2hVCU6c4S4w2cZIPGjIsS5JE8rmh1XL57yf/ij3+E/+OZ32KsqpAgcT0vmNnDi4E454YeXL7k732PjAp9tz3n/1h6H60t+ZK64tZzhup7XpoLtasXJ80sKNeOWWPCJeUooMvJc8tYbr/NZf0m92OeWypk4QbVdcRR2+HjG9uIl1g/kUrHVBXrbsq8dSsGyNJirc15zPXFVcHu+oju/YhYD282U9fKI12bHDEFwYQbeKyoeUKECeF0yzTw7Ipet4crM+ftmxYOq539eFsz6BpcPFHrC7WmJKx2DDRQxgyhZyBnf+u7f4dlP/7/E3XMQkMuKv/rd/w6392+zevGY1ctnnL56Sds5fuNv/3fpmx3ODGRa0e62ZFlBCIGmbVgc3eN7v3mHq8tTPvnTH7C/t5eAXWj++t/4W7z37W/y/T/8Xf53//F/xLZpOJjvf+399jUz3ch1cqY1hqvdist18unvLfcotEbGElFoiiJDiIh3NnEQgiPXGVVek6kJWrZoWeGtAJ/eilvbQdOQpPJq1OxGdrsN1gWk0nhvsUOPsQZrBqyxgEgs3gi77Y6iKlBSpYLtLDrLKPKCTdNQFCVVWRJ9wCpDpjXRR4QW2MFweHjIX/j1X6eqCtZDT2cMq9UKZw3VZMJg0n/XuwBCJlSiTfI05x26yBERbD+QZxkhRnRMAHU1UQxtm0IZpSS4ElFJQkwPlM1my7179/jgw2/xL/7wD3HWYLzFB4+xbpRXStqmQStFb02CrYRIb3ukKDDW0nYtZdkwmAmqBcoaQWQIDsGEsqqoywo7DKx3u6RqEAV1Pcc6i7OW2WSGqhVt29F2TZona8Uyr9jIDV5KZFHRWoUdmnScJiL89Uae6xqbZDo3R7v4L9XWkS+b1vr/GiXx3+z1JbwkjnmoMc1mI4ggk703zReShAF1HRF7/Te+LLbXg4pxpvulM4GvfhNSNAwIYamzNCrz0nG5XXG1WSUYCSNcSKYl39APZJlicvKCTXT873cd33rwOrPlhCpmvLO3h29b1r7htpL8aHvJfl5wO3f88eULqqzm3WzKf/HiCZdWcp8lm/OHtLtLmrjldrmkmM1Awv1iwh1VMtiKurccnL7EbRrk6oSVtXQ2cnF2jrWWsxh5gqJ1DlEXzGcTquUBSI2uMrQ3lC6y2myZeo+4ytHTPfz+fR7rkv1SUE8mHBd7RCc4jgO5FuwJmNu0OM+VoYiax9stFRW/01zxoPT8tWLJPsnYlPWSz5steVZyfOcNDh58l/OfvIDouTO/wzv3PqS7uOT0i8+JAcpqzu3XbgGedn2F61uK2eLGsaq0ZDKd0PYW03cIAYv9fd4QitPTcy4vL7k6P+FP/8WO1cUFv/qrv8r5xSV1Pf/ae+5rdboxgsoEuoIgB4xraNoVeS5RkwVapUQHLXXSrXmPNSm5oSgK5vMph90evWnoe4cZWh49vmQ2XVBVNQRBEEmPJ9CI6JnNSpq2Z7fbsW0ahn64UQVIEZhVJdNJjdYa7wNaKczQ0bUtUmcIlRxRSuqkJ5YCpbLR4aUgBLbbLT5EvvnRd3nzzbfY7bYMQ4pYL0bC12a1TjNmBE3bUhQFnRlGBGV6D2qpEpPABXZ+Sz2d0Q8bzNilO9JSbDqZ0A9DYhqwpTcL6knN7eMjfuMv/xU+/fwhZycviSIpFNTIW/XR4ZwjRj2mESTYh5KaEBONSUiJtZbd6gI5c0wnU0zf4GyPHqVZy9ksLficZ7PbYEMCxpfVFOcdu77j6GAfhUxmjb6lKicoITmoZ7jgaXY7fEjx84NNgJvruT/x+og+2oJu9FLXu/5r6F38V+vwL/D6mdDCMZInypBGAzKOgPpkergWgSa6RIqTH1k+RL4McInjqu1macZNdb75b6Va75GxpVm/ZPbaOxiVMWSaIH3aYQRPby1BwLwqWPeGiWuZnJyxaXsedVseKsk7Rw/4+08+5sPFHX40bPi12R3++eYlXZHzb9X7/M7qBX3I+LVsyvPdJZu+Rw2SiY9chMg8WJZDyz2TeMKTdkUMCs5fst5tadqB4XLN1fklputwgyU4d/PzF5CMRiKitOKLuqaYVEyO9ji4dUx9fBtTlLiyoAgZmQ10nWflAnmtEVWFnx7yXFdE5akrzX45S1zu6Phmbjnwgb3c02EQ9KwHxy5UXHnJJlreKScsi4LMSYzJ+ODbf5P/4tPfobANHzz4FvvzfUpRkL0jiS5w5xsfklclq5OXrM5ekal0wpQqeQ7CCEDqmh1tmxCp+0d3yMspgw04FzDe4Vdr1lcbtMrJdcGsnHztPfc144XkEKsmGXt7BbN5jiojKIvzPcYVaJWhQo63Bsu1eaIbj0Sassg52F9gfM9ut6YzHboIdHaFCz1FXpJlNRKdOA3GY4xNDF6X3ryDGYjOIMhS+KRIy462bRBC0HYuxan3hqJOL9o6S17k+JC+QVKEGymTjyl7LM8L7ty7S17kZENydtlhoOk6dm2TbMbGoPKMKBLA3Q89eVlQFRVN15EVBTFGyrJks14laVs3IJTEeEtd5ARd4YXAjg+OrMwR0TOpa/Iso64LlJJ0Q09VlTcPrxgDxhgEAhNsuhmcw1rDYjaj71r8WNyN7snyjK7bEZxFa00Int1uQ4gCh0QXNblJqRTGGYzpiEJQlTUKwWA9h3t7WG9p24au79KDSijmxQShM9qhpTXDWGcjOI8z5qa4xOun0XVZvQmuEqR0kH81gfUXfY2nfb7ahV9TxxBJk3tj6xXjIySGMaFZfuWRMiaexURWE1/p5K/Vu9c5EmI8BShpaLsz/uj5U2IfYDAIZ5AipswxrYgj1nOSabTzNM2OQx/Yrbd8YzmjWZ0j8hxz0NGYHRe7Hu13CKVQnWe/ucAGwYQt5dkZod1xEDOy7RrXNCx8pIoDxcU5692Kl7uex7uei/NLnA2gMzKdE4sZoZgjvYOhJ7qB6Cw4T7AOvMeHwM6s2a42XL085WL6lItbt5gc7lEd7LPcX1IdRNadpwdql1EPA0XveWUMrQiIMiNO5rygYCcCVamZ1VOySeRpsBwXnqN8jq4iT33Dk9hCvMU8wl5ZQyV4cP8jisU9Dror/vxHf4n95QH91RrTrAjeY01DPUuL6rMXz1kuDyjKCogpzbieEiLoomCvqrDWUk2mzJf7HB7f5uzkhKIs2FxeMu8HIoL5ZDqO1X7+9TU24IjKYTLLWS4n7O9XzOY5070Jy+mSTFRYF7DO0LY7cp1jnKHr25FfoJN9V2eUZcbgM9AeHyRKFUAGQWNd6hbbbiAGgbFpoZblBUpKNJG+2RKDxw4JTN6E9AM2fYe1BqJHSMn+cslqvUFoTbIxeyKCvu+QOiPLMpq2TV2xVCitqKqMy9P050xn05Q04TyuHDWaPvEQqrJKQJcsp+97oo9kWZbMAV/RAxtnUUJTCoVQmkwXGNOjM5WSLkZ84upqRSTy4sVLNps1MfrxtaTNvkCk8EohGYaeTEmMGUh0pYyqLFLn5S3ODgRXoCdTBtMlna81CKkoyxlIibcmWYczTWt6iA7MQJbl6KygN4Ztr5nP5my2O5q2QYy6z4gAKZOjzruUdOEc2kdKKbHGpcWljCNR/8vU1VRlvpRTAamT/LOwSLshVl0/JCKCsdsR/isdqryZTF/HGMRIAsTLMK7awlceOGkJzQ234cvX/hVgWfqLbYjDlqK6jRpPIMYP9EPSWUspKbWmswZcZF6U7JqWSmuyVcCc93xzcUBzesU38pxl1fKoX3GrmhDzS+r1GbmQ5Lpm7+ULyjBQyAy2DWJ7TtsbnvWO89NzNl1DRCNjhlvcIo6Bk+QlNhjwkYJAYS1d3+H6Ft+3CGsRxqYiHBKO1YfAbrejaRr084KDW8eEN16D1rDOS9S0IndTdFRs7YaNd4hMMo2RLPRc9FegAjMl2JvucS5XXMYBUZWU01tcVp42cyynilw5nvmcU3YcysjeYsnh3Y+Yv/wTal0y7HYYZ9BVydXJKS8/+YTz8imri3M+/tEPefPtd9CZwtYVRVETVUYxnZFP55h+YCJH16UxOG8pZzXPPv2U3W7Dg9cecDc4Xr14/i9ZwP/Lr691pOWZoKo0s1nBYlEzn03Y29vj1v5ttKhpW0fbbRm65qYAughFUcAIEVZSMK2nqFzgosXYiO1LrMnoho6u29APlr7rxuN8QAtNVBIfHFJEnHeIEFB5BiLStGnuqEWK2BBCUE2mQCJkZVnGru2SftI7umGglCn1NsFJEuD85PQVL16dkhUZfhjod5ubMMm7d+9zcnIyHssdziZdcqE12TgjndYlg0lvrqqukDrHR6jrOiUuoCnKgrLIaZqWZrPhzp3brLdb5pMK4y1XqzXej8oH62+iuJES4QMmetquZVKWo4IhWUnryZRMK3IlURK8M3TtDiWgNxbjDZnKkSojz3MCkTwvMNaQS0VvBwafHlZCauqRL0xw1EVB1zap046BQim8FJghAU6yEAnWjhZrhxZizLNKxTmMbqCbYnNd3EJAhZCQnvEX3+1ey8OuLyGSCiGS5GPxWkomEq5SkjS7wkOU4GVAhnT/pTjvUSY2BiaKfwnULv7L/kF4duvPKebHXG1TF6miJxcKYmAYY7OUzsilpGl2gKSUgvXliolWKHdF026pypxLoaiGhmlRsY6aYbfBS8GpyOg3a3ywbJH4TUOzWRN9QMsSNzkiW9zChIhRGVEo8iiYSU1DZJpPqINnFyyNNoSiREznKDPgh544dAgzQNekZIJEn0GopA8+efkCIzT95BDfbjiwA4dR0jm4BEKhmIoJMy3wJsVV7Wc5uYyU1nJpdigcRT8gGstD94TVYsrx0W1mMvKQliu/Y5bvUaiSe7ffh8snnD99Tl+23HrjbV578Ca33zSEIGjXl6y3O4wxXLx8weHREYuDQ6JI6o96OkOOvgA5xjV572g3Oy7PT3n+8hW//3v/jF/67nep8oy9/T2qSf2199zXd7pCkWWKosypqoqqqphMJ8yXS+psiRng4vKUi76lbbZYF9BlfaNhjVGRKUlZ1WAcg9XstoZ2Z7lWQgbv2G03tG2LEIn0VZSJiTAYgXGG+XSSYs6VJoqAM+mhoETaOBdFQakVInjKoiCOeV2DtYmQFSPOGHrTk2uFkoKu3fLw8y947cFrtJsNfd/StR3nr16kuWXfUSiByAsyrTGmp8wKqrrCW8etO7eQeYHUDqU0aVwsyLMEtS7zDOscXdtgreXxF59TFAXLvX2Ojo959uwFi4ND/uj7P2AYhmQJDv7aLU4mJM5brLVJxhYCZa7JpMA7h3OGLKtRmSaQYOe73QYlE5siAkKL9EDsWvquRWs9Bmc6XHC0/QBSkZX1KCkTyUmoJFmmcaZPfAxniSqidEZNBO+wMgWtyHH+jFRELYmjvToyFt5RDCxGQpoMARV+8QU3XeJni3+aEoyM6y/HINdgnDQtScwFMY6wgwIhwjXdNUnhRv2ulGMhH0fCScWbLinkzUzUd+dsnv0LZntvQX5Iu7pk0zd4a9JcXghM34/cjOReXG12uChQRcHp6iLlELaO9dBBDDg9cGosjenIgBDTUjYGDzJHyZy9wzeZTBdsnefUWDJnUc7Rx4COAqVhK8AhCTpjv5ohfOC4qBhMz7ltU/ir9ah+h2u3hNkC+g6MIbqBxMM0EAKr02f4POf1X/9rxOmEK9ez2rUoLVjKCaUXBOcJhWJelhQ6o1YZrRkospxaVSyynLZp6ezANBr2dcG5z9jmkdvzJTsBz/st9/eP+eav/3vcnRxjjada7LE4upvqwmCZ7R1Q7x9izcCLz75IQQpljcoLut7ijE/gJiFoN5u0QJeSrtnxe7/1T/nk84fk1+PFIqWo5MXXW9u/VqcrJOgsDZnrcsKkmlHkFXleUlczqiotdNpmx2azxjg3JkBotEpee6kyovVIscfQb5ExkGeKfjC0bcd61+C9Z1JV47IrSwU+zxFEMlHfaB1F9Ox2O6qiZFrXZFrSdi3OpQTRvm8wzoHMsC5ph63pUyFylvV6xXw6JdOa7WbLJ598zBtvvsUbD+5xdX4OUpBVE548foRSr7h1fEQ9m6OyDCUEdVEwqUpcnrqkzcUlbdumlIZCs9v2OGex1mCM4eT0hLZpqOoZd2/d4pvf+jYqy7i4uGCxv8/t+/eZLmajRVSMHaJEjbbT9WY1al49zg40waNEpNAZmY/4IHBRUciEr8uzjMEYsizDjHrpbAzctN4h7WjNLSuGwZBrT9e15EU9LiSBkJZ2WZaN2umYDBDO4cOAk4G9SYVQELOGaBU+QougFTIxU8diG8UYHBgC0nuUdSggEx75ZyCCPYwQ7+t5dARkEDfKi2Stjz/zKy19x5GDlGOBvbFY3BTx8aUnJkPkJiE8NYBf9rzXDNyhO6UfrqiOv0l5eBdzek5wK7phoB+6pMwRCYrZDgYfYFJP8J1BOM9cZygvqWOGkhJF6pSnYVx0C8F8PmOxOGJ2cMhsOme3ueJye4XZbhHOYqLHy5gYHXlB7Hv8qFkXWvMiOKSATCveufcu1dkFl82Gbbsh5jlCF0hrEdOQJJr9Dt+swQwwjh62L57z8X/2n/L+v/f3KL/3l1g3K+anL5jZFqcEh2VNXRXpvyNT0auqklKAiiKR+KRgXpVMtKZoNjzeXJLtLTjWE07yLWjJsijZy3KGpqdteo51PqqNItp7pMgwZUk1W3Cx2vLq+Rl7t+4xOczJspzgGZ2I0LUNfdehsmSKWi6XrNZXvPPgHT763rdZLic8/OQn/MHvfZ9/9z/8X/zce+5rdbpSKfK8ZDZdMp8dUpZzFBnBj5HpUlKWNZPZkuzqnM6sv7yhY8B7k2DkVtIZR55N6HuJCwO73cBqtaPrOqb1hKoosNYQgqNrW9zQk0k4OtynquvEdLA9l0XG1TqBONZbgxsGZrMapTK6LjE+wziLve4qopREH+i7pKl1Y6DmdDqlKAve+eA9bt++xe/91u+wWMy59au/wssXZzx5/Ij16scJGl7X7C9maCnZbDdsdzvW293NmzCENKgz1tK2HSDZ3z/iw4++zbvvvMtsPuHy8pKuHzg6Pub1t9/i84dPx9lwQVlYjIHemDTqswYzpHm1VBpvDaWQeMDJiPUJA9n1Bq3qG/hMGLflWikGN+BdTxAKGyLBDVjvKKspeVljvEV5T981KKWZTnP6wYwc1SyZTERAeFDOUeLQOlKpyHJeoWY5MXic0mxd4KwzbIzHXU9Ax9EP0SOdI9eKqQhUIiLFn4Fud9TepuFr+lAgEarEOJdO47w40ukSeQwR05w6Xo8axnPbOKe+5rdeF2quC21M3xOAEK95vIDIkXnNcu8ue/u3OD5+i+w7f5GPHz6kef6Q7cUrht0OHR1E0FVOpnOmswlKjXDuLC2Ogw8UeZEkjki8zKCcoosS4xxRV5xs1lxcnjInPRgXeU1mHefDgJca4Q1NVuOyKVFqDuoJSx8QRUa0htPNFf+8XRN9pNaaZVVyvttCPU2mHW/ph4aQLcmmc8TQ4PuW2O6g7zDrK374D/5P7LUrth99B79/i3J3ycI2fNMbPiAjj5GZkEzLfMz9U3Qmacb36mm6f0LkaugI0bHcaWx2ga8rjmYL1utLNjGyrCbsH92mKOvxh+mI0WFNj2kb1leXPHv2hElRcffNNyjmC7KyZsQUEkLEDgNKKeazObtd5NatW3zn/Q94/xsfcHTnFsEPGJfm3F93/fyiK1K3M5/tM6v3qbIFuayIXtK3A7loyfJ0Y+U66T67rsOHdPSN1tJ1A32frJNFXrFeb+mHgc0Ik/HOcbh/iPPpGE4M5Llif76gridM6gnWGnZNy9XqktV6jRkGvB3SbFUK8kmVjszO453F+siuaSiqJCsjpOIblcC5wHa7IQpBXmYQA6Y3vHj+illd8Prbr/Py+Uu2mx2Hh/u89sZb7HY7Hn3+OZ9//imff/oJXdPSDR39qNnVKnFsi7xgvtjj3t37/PL33ubtt95lulyw3W04vzzh6fM0s37/mx/y5lvvsGtaXr54zg/++A/ZbjbptWuNcgFUoGk7UsKuRYeY5rs2JfWqPMf6NFIIWcA4jw2CfAQE5bnG2HQki0LQ7bYJmiJV6qpVTwiBPKvohoS+tM4m0ubNJt4zqUsYQDmJcIJKV5AFqjxyNMmZVgVCKfoAl51Dbhu68xXBjYVMjkUlCDSCaZ1xNMmYlYoq+8XH9YivjDlS0MB1EUzz6evpiBCMsTeM2YPXS7NR93BduMd+V0iRbM/xK7Pr652dICWCaEVW7HFw9DaHywfcPnqTw+PXqeoFQkjOm4FvvHfEy7sfoC8v6XeXyN05CxkZInTOsigL9iYTmrbBDB17izlS1Vw2LauupQuafHFI5xz95Rmr3YaeNWG3TfJPAl3XEKxJjOtqwkxXqL5jtWsQZU2IA5cSLoNHGVjUE27fus9J09Gajo3wVLpkqipM9FgB1jlEXhFFilAvwxJ7dQ55CX1HHDpCb7n6//y/0f1AfP8DGgVN4zi5vOSfnj6nEpa3lxPenezz9mSPw+mcKs/J82To6Y2hi4FKapY6RzjP5dkL9m/f4265YHb8Hndyz96sJAZNUVXpZOIjzg5sLy65OD+laxrmswXOWZrNNgUbqByBxNlA2zS0bUtWlGlf4QPRON77xtscHE64OnlB8I7tdkvX9l97z30txLwsK+q8IlcFcoR7WBPYbVrcAEU1JI+9CJTlhLqeMwwdQ5+eSE3X42PK8No1aSPe7LYUOSxmNaFKcy1vPZkUZDpjudijKCcgFOumo+8aLq8uGNotwTmc6RN0RUsUgukYm951CTDTD5ambZFZjpaSXEmSt0ETMGyaBq0VB/sHlFXFp198xnQ+4b333uX4zh2Eznjy6DGrzYbLyyuOj27xm3/5N/hrf/2vYQZz80NYr1eEEKjrCVVZpYj1skZIyW6zot1c8ulP/5Rt1zCfL9k7PKQsSuaLfbbbHdtdw7OnTxjahqFrmEySWQFSHtquaVFCEaLFuQE9UqR0rlNXTQoCNdaQ5zkWweDSzehDTFk6yNEclnKxhNQpXh1JrhOLtShK1pv1iMLUTCYT+lGPrJSkyAosaWvrrKPIJHvVhINFzcHeDJUrtoNFbTqMlJw2DWbbE4W8MQzICLkW7M9r7hzM2J9XzKtffNGNo9Y0jg+IFPNy/cl0v99E/YrrzjU9lsRIEBQ3brP0K2Euryvs9Z9FopnpgnpyxK3b73N8+02ODl5nsbhDpkqQmtb1rHrL1jjOTWDn4QpJUy1w1QK5d0ydC3pnaaPg3AwMlxewsYgoKaTCBQe7lr5p6POcev2IPlNkmcSXOXqzRtmEkowxclTMOGlPaETASGiw6CrNfLUquVNVnJy8xGYTjJJc9pad31DVRyymC67WF+xUhSoVi7xgfXlJmMwIc0GtoNtd0buIOJ4ihhbhLaLd4FZnhO0W81v/iDoa+g+/QZjVeOvwEXoh+X6z4Y8vr3i3mPI37r/NW8sDMiXIshypBBWS6CLOWiKKd+6+xf7eMVIpsr6nLBKVMMiUfI1ID0LvHKZrIUTu3r3H4tdr+m6g2ey4ODlngaacpdNx13UolXZE1hoiUM6mZC5nu2s4OXnB6uqK7WbLdDL92nvu55sjRIrfVmoElQcIFox3OBEYWoPe7ajqGoSiyAsmkzkhgjEOKTOELPA+0I6SMCEEe3s1xjqMFWhSqkMugEwzmUyZLvYZjKFttgzDwDB0mKEjIjA+jMaHBD0/3JszuMjF1SWRpN/dNg3WeYbBILyjWi5QQmBcYgDvmpbUmEjOTk8YhoF/8o9OqaqSW0fHVHXNa2+8xsXZOc+ePOHx48/44vOfkCvN/v4hxWRGXtcs9vcSX8JYttsVl2cv2Ww2rJpdSvxVkmoyZ7ZYoquK6WzGbpMkNM45nr94MbpYqqSqUJrBJH5xN/QQ40g5a9PScNQZhRCJwaOFBCFwMdL0A2Ud0tEJiXMWqTRhhG8LqchVzmANUSmMM+RZOm5lIWEe22aDyhK0qC6rBC7yKfHhen4ZbMANnugdUmmyXJMXJQ5FXniK3FJoPR6p3bUglRgCZaFZzCccHS442p8w/9fY9P6bvvwYBS/Ho7+I119vEoFxLfeSiSyW7rFUbceGGCG/VECIcakob5reCCqn3rvNg/sf8ebr3+HW0WvMJse4cUk3OE/vBf3g2A7pPdJaQ9saNtaz3ayQpsHuNmxPX/DZ2QvWzhCmewRRsz9YqizDFAX2YkMsC8gyZosZEz9wP5/wcttwcnmBO31B322xk5oQI6VULG7f58GsZtc0CC+5WF+xjRJTVASleWUD2cExVabJvefl6oJOTRjMjmmRM5OSre9wOmfXe8q6xgFWCZzKKBeJ/yGEJus32HY1ckkgliVxt8X84PvIvSnh3Tchg7gz0EaikylAM8KL7YZlUXE4maBEZJJppBBkkymz6SH1ZEmuc6LURO+p51My2dLtdhTTPYQUeGvwvSEEkEVF5jx7RcFivmB1vuLZw+cEdYEsJ8QswxPYrDe4LuUtOm84ffac09NTQvRcvHrBYDu22w2vv/Y6Rf7fcJF2LfROTiggpq4p+kCMjuiSnMs7k+RLmaKqymTVFZ4QNTmBIAza9dSFoChKBjdwcjIQXMR0O0QIuOAoyxI7CpJ9SECbbhgwpocIxhhi8EzqijLTHOwtCFGw2lyRZRnbzZamaVO0TIy0fY8oMvq+I8/z1A3aFDUTYsT0ifOwWl1SlhOePX3GW2++yXqzIS8Ljm/dAiG4urrk2aPHXDZn/PSHP2DTtvTWMS1ymj6Ry3KtybUmCMlyb4/b91+jnk7JiwopBdv1hiIrmM5mmL5jvbpivV7xySc/QQhPNiaymsHQdQ06y8ZNuSeEMDrQxnmhSmm+vTHMypQW0fU926ZlOqkg+MRpwFJVNb11aF0glAcvEutC6sQmHjfrZVFhrGfoO7wP5FmOkgLvHUonhmxwCbjjjMcOFtMb2t6CUlhr8M6lXz4xHGQUBDEGlUePUhmTumA2mzCbzqjKX3wEu/d+VBmkdFiiIIb0dd9IySJf0eamWW5yYcnx9DfGst80xKnLjUKwPHqbX/vlv83br3+H/eUhSiiGGGmtozUOGTy7rkskNh/oz0+4vLyk323Ynjzj8ZPPePToc1btBlFUTJdHZIt9JuUMc3bOUNZcTvYp9/bYC56DIbJa79hJhYk9u+6KEwnGgSJyOJ9ApjmPoFSG3V3w6atHN1Sz/fmC1/ffZLXaYnzg/PKMba4RWYGMOcc6514948q2dKFlG2p0PWWe5azPz7HzGb4oWGYZl+enuGpCttijaEnMa31AlBkBi5rOcF2LXG/wuyviH/0xs7szmNXs3IAwkcIFbhclby0PKXWGIyKkpDOWuiiZlhP29x8QZGJv/+iTR+wGKEvFhweSXPYMmxUH1QwzDHRNi2kaQkx42KuTM4qiYLKYIbOcSOIiZ1mWCII20Qb7zZoyz0AKzs5OePjF55i+pcgV1ht2uxW/87tfsNlt+F/9b/7jn3vPfc14IYUp+piQi4Nx6YYcRfzODeRCIFSCI1dFTa4VWaYZfKCuKqbTOd4Hzs9fslld0vU9XSfY7Sxd2+DMQK7SWKGua6p6junaceHU0LQNzqbAxUwrFtMJi1n6te0G2r7He8d6kxZyg00ZZChJdJaoBUM/pI5dp4RiJQTOB3qbWAyZylhdXtDsNrx6dYIQgtXqkqurS+qqYjCGejahmFR4Af3pKafPn7HbJiBNJEW2v/Hmmyz2D+nbln7osSFQVo7FfEHwISkIrKOqJZdXK7z3zGYzLk5fouoKH2AwiQTmY8D5lE0Xgr+h/cvrznHsqLquQ2cFZZaCK6USTIoKR0r6oG9xSJYHh/RDGlG46BnMkOzbWifympDkRY4xBmc6jOko6xo7GLq+o6onlHlBbwayPKPpLKdXKxyO6TBjCJ5N17PeNbRdR/Qe9xWuAUSi92OEShqLDF8PZPo3fiX1giAwZqL5cfQqIkGOdt5ActONc5IEwUljsRDT/FaI+BVVgiBEwd7iPn/91/999pav4XvDq5entMZw5Qx972gur3h0+ghnPGHoyAI8evQ5u92a7WrNbn2B810K8cxzosrooscOBil7jqopZ0OPN+fYl0+4LDWnkyka0M5xMJ0jZ/s8W18Q+57Q7Xg5qfBCIZVmOSk4yo+5bDeIakHQmot2w8l2TUQzm0y57SZcra5oCkfwPS+rpHI5OrxF3K3ZIvB5iSnnVHdKOr8jaEVb1MzefJNd12Kip5gtME2LVzVqOie2V2jTIGQO+Qyf5bA9Z/KnX6B/6UN2rUX2PaW3HE7m9MNAVk4odI7Kcsoioy5m2GzGT086ZsuMddOzigV6mnPR7Hjy6pxhOKNUBXt304K7uVyxubokqwrOXrzi0Y8/5o1332VxfIvlkWa3atH1hOl8SjWbEBsoyxrft2RFjlQalGS2mLILPe998A6PH3/B97//Odu2TXFVX3N9PWUMQfCRoTM0sqPPDd539P2OUmfILGPoNJBALlrlKK2ZzjJmywMm1Qw7WKwZaLYt7eBYXTXstmk+i3d4qZnWU6p6SoTkYtltcMbinMM4i4iBxWzO0cE+eZax2ja03YBWkq4faLse55J1OCISLESAVqlYKZ3Rdcn2WuQZw2BxxjKta4SITCY1fd/z6NFDqrJkf7lkKKs0v93tEELQdx2DtRwc3wIpx9e0TfzdELAhEkNgs93gfWQ2n2ONx7nA/sEh0QcWyyX9YNlst1xdXDCtay5ivIlCsi7ZfrXQbAfD0I9Q5Bs9Uxod5FlBDOnYb4aBoqrxpIejG2eUdoz7dt5zfn5BWZT0QBYtJljariPLC4KPzOqKxSTSSsGu65KmN8vRumDXXtEPHVU9RUuFs56dc6x3G04uzpnOZ6g8p3WBi23L0CepXgzX0O/EKhh6w3bdsKo1dmjT7PMXfF0rEoQIXxbTEWROCITxIXeT/EsEef3GSrFTSaWQfk8aqyiKouKt13+dH3/2Ci9PGIwlBMluN/DctOwGw3FVUnQDJ+2GoduhI2TGsjk9YxAeigxsRGpFVU+QecVcl7S7K9p+zZOsSsUzK8m7LZc7i9vN8FmBJ/DUNSgliVqzt9zD7Da8Oj3HVTOoZ3jRsZrN0UXOcjLjuCjpPz5hm2koNNtuS1dIytcfcEcWvHzxGV4pXJFzsVtzdHyE7Fs2QrCbVEynh+QvPqPLc/rplOkkp+m2hHqOqRdUk4behNRVmy025AQnodAInZGVJd3zNWH2CLUouFdUZDJjL6+5N99HjypnIRQqnyLmd3ly3rC+OEe/PGcnYbe9wp5fMdvbZ6qukP0Z9++/TVZWZFkxjjUku8tLXjx9wmp1hVCKejZFzRXOOFar3Uj4M3S7HdYOlJMa13dcvTjn9OQlzS6ZTBaLKe+8+w6nZxs+++ILXrx88bX33NfMdNMsd+gGNpsd+IjOBC4MaWQgPSGCcwOxC4ToqSdLtJJMZzPmiyWZKjDKwAVsW8dqtWU1pjJUZUHbevKsZFpPGQZH27WYIXWvxhmscxACk7pCKM2uGzCbdhxuy4QTZJRrIXDeo7VGjRZfP+owzWCSPReB0hlFofEhgUWmoxxts15z8vIVt27fYvqd73Ln3j2ePXnCYrFgvVrRdElPvNtdjcGQOWVdo6Tgar1mGDratkmzZLFjubdM+Ehj0oxpOmG73fInf/on6KJkfXWFFFCUJQQw1mD6PsXGC5PSdmPaoaeOSo52VIkLiYplXQTpEH2PEJFNP6D2kpNPKU0/WJSSDH2L1FNQGpVJVIAQHM4atJR01jLJEww+D9B1DXlZU1cT8rykaxvapkFJxTA4hFRcXG7pux1OPSefTggqZxcjJqQZ7jVtLEbwMdK2Ay9fnhJMS11qnP+zADFnxFGm/y9FRITEphWjRhSuiy6JxQDjOCE99JJK4Uu6goie/cUbCLFkvdviFZyd7hi0Q/YuHVmj4/H6jNemUzIfWZ+fsR06nGnJM4nsOrJdSyglg4+Y7Yos27JXv85yMiE2O/phjTeWs6ogn83JsxkHRcndyR7nlxe8OD/F5zlxUnORSeZ37jEXgtIrFgIeX75gM+zQ5YzOW0JZcHDrDhPjaNeXrHSgzwoGr2Bac+uN92l9y8q22GnFK+e5d+9NXG9oMuh15P73fpn1qxesVca2mnDw3oecb3b4LKeWiuHFKaGaofcPsGZAtD1xcIiiIitz9G6DuOoopzl36pKj2QQZJME5dJ6n1OysoguC0+dPeBkEVgT81Zb7944pbI+ZOIS3aNdSZCUHt29TzqYolbIclYKXj5/w8PPPmdUT5vtLqsmErEj7p6YbaNuWAc92dYmIgXJWs2rXPH3yiEdPHtJvV9w63GPoG5bLBb/6q3+ef/uv/S1+/JMff+0t93OLrhIgfMT2lq7pE4kHSRSWqB1eStCCKBOYxfqUGVXVU4oiJxPAaGY4PV+x2bR0bU+MDiVikikFz35VkWlB03aYoWcYOnzwDM5hrCVTEpXltIPnan2JUoIYA5lKb9x8jFQ31iQNpBAoKZJm1TryqsJZS/AuLeF0MjpYn8YWZVVh+4Gf/vgnHBwe0H7RsL93wPHd22gluXX7mPV6RZGXBOs4PT3FeYuSiuACZVUghMRZx9V6jXWWSk7YtTuE0OwfHFJVJWfn50ghef70CcYMdM0OrRR1UbBtGoxxWDsgIihZpmKQ3vLjrClZmqXMUYI05nEGpRQmGpSWWOvZNluKPB837xlNt6MqCvqmISsmxGgpigIfND4Eorc4A71INkdJIMsL+m5HNsbyGK1w1qRstrSKT/PJ3tGbgdWmQ1Q1VAUh0wkBcx3ACMTg6TvP6dCzWa3QIuKN+69TJv//fsUo8OFLMKMaORGpURdfdrmCkSEhv5Lvlu75EBLIPHEVJLma8tmnH1MUGSfrFdNqzsXTZ7RKsCwn3PKel5srPj1/iSYyF45dt8Y7S2cDwhlUJsgRFAklBxFO12cJQKNyDmcL4mbDi90W7wN9VdE2O7qmY3F8m3vLJVpo5GD5PHZcekcuMxolkEPHfm/R65YwHdhNSh7HGlRNVhcczx7gT8/YaUvQkRWRTV1xtLzF/OQpOyUJWcHLznL3eIF5+hC32GfrJff356y2W4aspFxOqWJPW9bEoqT0jn6wlPMD3Ok5MiuJ6x2Z6ZlnBdPFEmMb9kLNUhfsZQWVLiE4Jrlif3aArQ758VVPiDlFofA2MJgGd3WW3jPescgVh9WE470lyzu3yasCb1NWXbdrePzoMS9Pz7j97TuUdZnUUFlGPZtST0pOT0+ZHu5RVAWZT2ahZug4257R5YaT7Ql7ywkXl1ecnl/yj//RP+H99z/iN//G3/za++1r2QshBKxxmN7gakuGBumAIXVeOlkeg4t4O+B3ES8EVT+gZU/TWh49fc75xRUEmxCM/YAKHoKlyFLS7On5Obu2p84V1lo2TYsZBqpcMZ3MEULhTIeSKRE4IkdfesIXRgKe61mno8hLRBRkmUqAlpiKgNQR4mgVjol5mhbNnrbfEc89WmWcnb7ik88+5p233+b2vTvs7+8lC2VZsphOOb+8IMsr3BitXZYFVVnRDxbv0gx2Nl2y2N8bk4Ydbdvw6IuH9H3PZnNJ8BElBbPZHLdZMww9g0nb69ToekS8ttgm+ZXUCinTa1FSEwWYsfDmKkeISNfsEGKKwJKXE0RM4BysIUaV/OTRUxQlfd8jlEQqhYiRTOnRoBIJHjbbFUVRIiLorMRbm5gEMbK/f4vzywt8dEhZJNRkjDfsAmIaLYzmLvwYdNmanmgN0f3iO92v2jNiTCxdMZoWECSt7nXRvU6HGIE2cnQBfsnkDcQoUEpzdbnj6vKcWVVwdbHiAkVUirbrGOQJB8s9Kq2wbY/1hsvgyWYTdNej6Fg7x5ApVJaRKcVBVtH1HbtmBzpDlDWXMZBNZ0z2D9GDpXCONnqulhWtGVBas8AzbdbU56/os4J8NiEMAy9mU4oHd8jzmjvFjKePfsKmaZH7NU4rThQUb7zFLSInj36YwD77klWjWD54l8nqBc9Xz0FF4pBxd3/Bc7PlqvO89uBNjuSas8qyqyPfO3zAH+5abFZxkN3i1ekKW1eIqyuCKsEarA5shsT8mLqMfGs5vF2jIizyjMPJHnVRYPUeL1xF5yz9y+fcmmi0ccxCw+UXT1npgvZsxa/+pT9HNSnYu32LvK6IIeKNwQ+GoevZbJK8VGqNsT3tbktUkigCMhPsri4opgWTvUXaney2XK2vOOtOsRPHu9/7kOZ5h7UFb37wHos//BGf/vQn/Mov//mvvee+Ng3YWUfX9fR2IIQKIQQ+DigZUsHVPkF/Qw4u2VKNsfRth7eBi8sdp6cnyODouoam6xiGARESrOZoUbMbBs6uVlRFwdV2x2a3pW9bcqUpixlByLRVd+bmOFhVNbu2JRNg7UAIAR+SiwrhgZgSU8scP9LGtJYoKRDBkxUZsRjhOc0uYR+lTGkMdcnv/8HvMwwDMQZ2uy13795hUpfkmeJSK27fvo3ziRsxmUw4Pz9nvlgQtztu3TomuJQMIfOC05evsIOjaRvOT19xtbri+NYtXr56RVWWibcQA9b0iakgzU3hY3RzCXzS2JJoZhAIzibB9qjg9yGMDitDs9uO4PIWoVJKRogS47bU2TIVdGvJs5zgzeioCxhr0VITgsUFz9C79Dnn8QLyrEh/jhkQUnDn7gNenT4jKIVTEhsTB1ZeL89ubF7XR/hACOlH9GfBkJYouOKmI0+aXW7mt4mlkBZjkpT8G4Mg6jTbjTFZiNM8N/2z0hmTySEidrxcXzJf7HE2WHxVcG82Z9vuODOGTCgeLA9ZrS85a1bEABmeaAd0CATjCd5hfeR04sknEypVM8kq5uWEz/stjUrg/7KumTmHOTshe/4Mt7ePIHLW9VzO58j795mLjOl2w0nXYPZmWB9AOJwYKN/5gImU+NUF53QYUeOUJpuV3P/oe1gfObt4ijWwqZa8vXebplvThR3Pd44/9+Zd+qefM4QJd4YFLzY/4UDe5pu+xA1rqtIzm5R86/YD/qkUmCjRB0ushzLTdNuGXmmutOQwrzB9xzQWvH3rAC0EtdZYkfHT5xectytWmw0TBRsTeHNvynpl2M33+Lxx3Dm+D1lOoTNUWQIC23WYdocfOrJM8O1vv8+9u/tMJwXb1RUIxaTvEVrS9zukBDv0dK2iqEpEJhhiRzmZ8Je/99d57eg+/7f/63/CJ59/ylvffI+/9Xf+Lv/g//z3uTjffu0d97XqBecS39Z7T8ATYhpEqywBbcKIsFM6omSOtQEp0py363pOTs8I1hC8Y7PdYQZD3zXIGNF1RW8DJ5dXiBjpvaPpWjRQZCVVXROkYuh7mu0GKVMm2HQ6JcRAdBanJX3XEaUCpYnXEHIh8COEXdxYMAVt26O0RmUJaO6co2laFssli+mcU3PB+mo9RqtLXr08YX9vn08//ZT7D+5h+oHL1RWTesJ6k3CTOsuZzxdkWUGRDeR5zvQgLZeev3zBF4++oNA5WZlztbrCe8vQtRR5jhCSpuswY4csYsRYB0SU1KM0SSCQ5LoYX1MkjgQqZw15NUGr7Ca5ViuFc56maShKR1mmmbUbi4NpW/JqkngVhUwPMwSOa93quGAaIS+CpGIxzjDYgbKoKIua3vYUeUVWTejdl1KEGBLcJhljxwFJiCMQPC12BBH8zxK4fhGXiNeWXUbhfHpUfBWCE+HGGHHzscAY2S5uut1r5YIURRqjKYkLgU00GDMw2I5MTZgv9hguXmFsx7OuZbqYs4gWhp61s5jpFGKk8I7KGFo70JcFA6BjQOcanZfs9wO7wYB12E3D86IgP9qnzGt01xNPTrg6PqQXDmEDRlmYlZRxSXQ5oVAEY1hrmRya+YS7y31Mv6GrCyIDq6bnsq44Xk6oThw70VBGz0vT8s1f/ogffPq7FFnFYT9l2KwxjWezesiDtufxT77PJ/oL3nhwxJvLBXffPOZ+tqIqPYF9xHRHaFukzhFSkJcKNXiUUvi85rL3fFsGcpVSjn98avjJ5ZYqm3J7b0ahJKevHvMvLs44P3uJiYILPedbh0s2r54T7+2R5xkiePpuS99sMF2HUoHDW3OKyiOCTtmGbYMdegKe1fk5UTiCG1hdJBVPFJ55PeN//Hf/J6gQ+e3f+i1enZyjQs9v/6N/yC//hb/I3/3v/V1i//XL4a/V6Ubr8dEhSE9UKSNSS3KdSEc+WkyATEQyrShkigv31tHsekzXUWWKRyeX2GGg7zusGRLMIltyud7gjCEbb9BMapTW6CId6Zw1dG2LtZayyAgiEbT6MYTSDQM+gNQZduggejJdJjtrBOfdKHwPRB/Y9QNFFihLR1HkkCm6vsUOFc5bpBRMqpKISEaHq0t+95/9LnuLBfVkQlFV3Lpzh+gDg7HoXLE+v2QyqanqGT4GtFbE6Bis4dnTp6yvrjB2wMfkiVdC0TQNWZGhtGboWoahI3g/dlapU/celFAjOSXFnouY5roEB1FiXI+UGlmmEQFCJjxm8HgRsVZQ5nXC6w2GPC8Y+pYgxgIbAaFSQR712ClFLc28CZFBqhHeEum2W4J1zKYLiqygZ0DmBT4YfIzpaP4V66uIY5JEHLWsSqUqp9SfCZ5u4iuMRocIEIlS4GNEfqWQwjV+/FqlIFI2nIjEkBBiUURCEAhyAoKL1YqjxTGf7S5YzOdMm46XVUZjBm5XU1ah4VxD07XMlWZGxjoOhKwgyoAfwA6OfFLBYImVRCHZ7la048+9znJmjeVJqfGTij54BjcwzWF2sCB6T29yQmgwec7ZZI64/xrVbMHrPvDF4x8R7QR9KBHG89IX5PuHvF6XPHz1Cb6YISkQfcvtd76B7VuenH2CfO0IXMFSZExNyaOfvmLaT/j40x/zzEHWbsmKnNuHsDs55SQMtG+94M7f/Mv88u0HnMYpJrvDD0+vcDJD9C8QUkHcEUXStp+3licnjzG756y4w8Xk21DNqYOhX13w4xevWDcXXIUkB93LZry7KMi3z9H5gr3lfYoqJ3qD7df0zZrdasvq8gprevp+R55NKKf7qEzjzMB2s2K3WScnqDMIIeg2GyZ1xWvHr3H14ozpYsbTp8+Z1ROMkfzw408Z2pY//xd/nftvvve199zXUMbAxxSKJzXoLKKziMoVOtPJ4REcPkQ8gagEhZqgZJq37rZbtJZcrdYpDz447DCk5VM9oRkMbT+Mce2AkukoHANKKEzXIISk7TtUjHgkWiiapsO6nhBTmCUqw4WA7TqKXJNneQJjeMdgIiqOlveR5JU6m0CuFQFN23ZkKrETppVDacXVZUqBuDw/xTpP9IFXL15yeHTMxeqSTKUZnzGG2WJJUZQ0bUtdlrR9R28tednRDwkn6dxooc2rUYQdGQZHJTKMSQT+4B1CJTfNDY9WJphJGOPpE0JS4d2AC27kAhtCD5nWKJ0hIGEZnRuVDx5vHHboRklTwO02KJ2zsZZJPcHZBJ6OBCZVhR8Lp3eGijIZMnxPiBE3GBq25EVOUVbkOktAoZE1IEZ6w01Ru3n4S8gEAjV+5hcvGYvXfxECruli/st5Ltdwm/G6kYVxbQkey/HNxyPTag8RSvrecHRUIs8t62HNfr5Abnc4bzjrd1TlhKx3ED3b7Q4zLSnnM/RqRWjW9ErSLOYorcmlYJ+M1hkutSO6DjHSxA73l9ztDReuw2uFG1o2GexmBWU15Y3ZAf1nj3moe5wFMShEFrhQitvvfhcZLKcvH9LOK0K+wPWKLkYO9JzdtELZFadnHed7c37puOb51XPeCoqjYZ9g5/zoB39Ee3HJ9GrLng+8f+917r79Ot/59jd5571vUmYZT18+43K9ZvfDT7lz3DN7/U3+SGmelaB8YKsLvpXD+8PAfLlEIyh9RPgVm82Ol6GnLC2LqzNif87vvrwgZjM2aoaY1uTCsF8vOAaWSnG0mDGbzxJd0LSYvqXZrnn5/CWXF5dstit224ZvvPdt7i72KCcTmvUq7YtGaaaPpIDbGJjPlpy/eokJlsdPHvL0xSmPnzxhNp/w6uSKZtdyenbOO+++z1/5H/y9n3vP/dyim9JeI3kORSHRWTJC6Eynbo4wJu5aovBkKgcp0AqccyOUPGDdQJlLzoaefhgSujDLUiaZGdLGXIAMaR7mAdsmlqi3FiUEUSYXWW8tQ9ehFSA1Pkq0lAxDCo8TKvEDhHCEIIhapMJ8fSwnJoLU2LVnOkuMWiWZ1DXDMJAXGVmuUUrgjMF6R7NZs2saNu0jnjx8xNtvv4m1juXeAlEofAycn59STSc8ff6SoWnYbpsxyTiiZPK+S+9RWVqIDd2AMQNt02CdIYxpEQmkHRDCI1U+btFT6GeWZ4BA64JoByIRBTg7JGtucJTVJC0IhUAIOdLefEqxdcl8ap2hLMdg8JAWQ845one4LCVS6CxPD0RrCSFwHahonGHMzUXnBXVZIU2D8+6GCREZO16ZuAsgk6NLytTtjrbaX/w1fr03oLFrvYi4+ayAf/VLHUdXxGuM5ZefssMAbsdivuTp9opDoXlelGzrguPLlvXmgs3BEqcURyZiL9eczwusUoRgub1/iLM9LQ4f0sJR6AxfV8yzKaFb40NgiJGt6flUphPUvekt4tWWx3GLETIZZGzHRb/i+I3XObh8SS88UVva1StO8zmiG3h9b48Fml2zJS+gtJ711pDPCj7Y3+NHT35APJyyPy+Zdpa7jcI8OuO3fvCY33jjPX765Dk8fsF0VvOdD9/nOx99yL0H93jw+pu4MGAHw/F0ylxpptOa3W5H/vIRR0Hwb0+mFHdvod64y6HO2HffZTopURJmy32sMfzgsyf8R//4n/Lq+7/Ld+/t8UQIWuvRdgvBUnUbDu7e5WBYsYyO+7f2eO2tu5R1jjcddremb7Zsr654+vgxF6stzjvms31u3XvA/q3b5HlOJlUKKsjy9DCVEhcsZVGyd3SEyhXPHz3F+siDO3eZVjVd33C4t+Dh40f8yacP+dHDR/xvv+aO+/mdrhIUlaaqNXklyUpBlivyXCPl9cxUEEVAKUlZTiizGmKG7Q1CBLq+py4L3OCwzhNIYBznPV3fJkuqENhxDqijoGt2aWMfE/4vQVoUfd/hXSqgQpZpRigl1ru0vNEqSc2swQY/ArlTVE7wAT9u1F0I9H2KXK4qyaQq8T75sZVM8eYuRnKlcIXAtA6Vac5PX/Hi1QnWOiaTREzbP9hnOpviTE/bDbw8PWW9WrPdbFit1ym6PTiyPGdS1bgY0DHgbZqbdl2T1A1DMkUkPqsYodnXc3N/o1SIowPqmpHgggMlCXZUTQSPEZJyOk/JBiSRv9KjLtnZNPsOybAQvGcwKS4+jp21cx4pQ1pOEhnMQF7XxOBQUiUNtR1SF9jsmE2mFHrLMOIyo0hdbJRjlxuul1ICVPo4SoL82pXCfztXhBuhLj9TP29K8M1vvRk5XH9cjB/78iNRQmt2ZOWM5uqMeTEhW61po2FWaHIhaNZX9HWFDILFpKZYbxgmGik0m8Ew2T/gwFr6Zo2aZGxE5JU3qOg5nu8x2w08dw1dDg6P9YYT1/L60SHLK7jwDVJGou053XlOxZb5rOSOVTx6+Bg/q6B2ZHmFXMPe0YKjgwesTs55ata4+YIsC3S7c/L+iloPLN2MRyZwZ/kaP/jj30LHwPe/eEj/+IT9THLnYIYZGv74T/+Izz//mIPDA8p6zofvf8jQdITgePUy6Z+LIk8nWJ1TrS9ZrTcMVclqMuHb3/4Ow2A5/elzurbjP/vsjLUoMYfHPBo8f3yxI+YTOmcIe3coVM03j464011wTw1859vvc3zvDlkmaNcXDJs1Xbtjt9lyeXXJydkanZfcv3/A3vEtqukMIQT1YsGxziiuruiGhEDN8Ji+5+T5U7Is5/zsjK7dobXg8HBBFEtevnrBbDZl1+y4vFp/7e3283W6uaSa5tTTkrLOycuMolDoLHWKMYVhoaIiL0pmswV1vsA7Rd9dobOUEFzkY1R42yOQlHlO07bEEFBKj359h5Kark+awxBjGgfkWYqUcRbvA9EZsnJKFDp1XyKkWS6ghST6iJWpSJGluaULMXFEgx9tv5pMZwy9QWtFVVXYvgelybTEOEupNbEsGZqWiKRtW7RK6RFD1/P5p59ycHjIF59+wmK5wHrHrmnBJ08+MdLstig1cgtCxIWEVuyNJTqHdx5je5z1o2tOj46oJEeKyJENIG6OsMEHqqJKSzMfEMGjYureg3eE6Mbu3CKigujx3iG0Tn+OTrHeXgmcGZCkJGEhUhpF9AElJZmSoyQqGUycSSYKHx1KqcQsDj7lyVnL8WyPPlh6M9wUoXR3pHnntQQLKRNn4M/EcCEV0f96xrjkjrrGPn71413bQTYh5IqFzliVkgfHt7ncrjlTksM332J6ekGbwaUUeAUH8wpxseZSBNalopGRsqy4O6nomh0rPxBRRJnSbxfTCbNW0PVbqEEFwXZ7xceuo95f8vpQsXr+jMuZwlUVspgwFAq1nPNgMmNje1zoaLorvhiuCGbOkRp4YzHjydnH1H7CsbjDrfw+h7c+4uL8jI8//xPcYAg6Z7Zu2Tw/4aIxzKuM470ZgogxhskkhcP2fc/J2Tkff/xTPvrwI8pM0bUdD157i9V6Tdf1vDw7gx/+kNfuPWAtJfsHC/5f/+AzPvn4c2LwqPkejyYPyPbuU80qTi9PmR8fUlc1u+0VbxQVD7LAW6JhllvePN7n8NY+1aRiaFYM2w3eWQSKoqzZ29vj5GzNbDLnwetvMF0uCSGMXBHBZDpLevkQUUXBanXJbr3iix/9kNlyj6PjQ/7hP/6HnLx8SV1PkJmmNx0XFxf03YCUX88T+blF9xpgU9UlZZnfQGNkluAsGWkMRoQyr6mrGXUxg6Botj1KK7QKQJKdtW1HnmWImIpq8AEfHdbYNA9TiWXQdSl8Ms/zlGTrUieriGRlSZZnaQkkJabrsTbFgruYjrelSiYBQfJbp6DH6+NgyltTqkQpnULn6ioFO9pURLSUZEqNx73UcTrnaLs+JVE4C8B6tcI7S7Pd0TQ72qFHqZy8yGA8jmd5ftOJD2YgV2lR6LwnOIMzJn0vIuRKIqXGhcRNEKMZIsuu8+bSjNFYk/zgJMWAkiB9BC1HGFGgbzuqqiIiGIyhEKmIOpv+PKUcwXlEpmnbljiqHrz3adFZliigGHkM3trEhPB2nNimzb33HjsMiEwyr6YQAyak0Q7XOyggyOv5qCReM2t/pqf8xVwKlb5MkQA1/1VfkfhKcb3+OQgRU0y7uI5nT3N+mQm6Ls3cg/OcNismekIhoPEtISjeXs4QQ8+J244RTzn3jw9p1iukbYlFTOD5yZTJZMre1WU65RFou5bPy0ixP+c1V9O9OuGkMrhJjcMzDGtme8cs3W06t8bEnkIU2O2GT9odoiz54N5rxBfn/HiyJuqBKlN8++ADKgtHnaUWlt3lFf/k0/+cW7Mpb8+WZNsVt7ICffqK9SfPIHrqScmkzFJ6NdC2HW3XobSirEqqoqRrO370oz9hUs94cPcuXd/x8SefgpCsNlvqqmS9W1MWBT/4wWMe3H+NO3cecOvOAz5e7zh7vkL6K4IeCJM5ORmHwvPuvTu8VTgWOuCuXpLRU9c5Plr6dsPu9JRms0kPfaURQjOpJ+RZxmw6Y3l8mDTnzhG9R2cFkIBG/dAitKCa1PzB736MjJ6PHz7k3v17TGczyqymLAru3r3N4Ht+5/d/j832RYq2+prra9QLEqUUZVFQV9eFNx1DgxAgFTKmrKcir1EyI88LrIG8KMgzjVYCa1xK6JVpA9/bAe8NzdDgnSfTGd5ZvIfdLsWqq3HL3Q3dlzE2ErRKMTRCKKKxWNOPQ+9EzE/LjWQHljHNQVWW4UIk0xo/bqGVVGnGKQV937NtGkKArMggCswwoIRAS4HIFMYatmaVknNVkmsZ0yEidLtNStlVKgHcTXoPKqWxzuDsACFHCpnCIkPA+5CkRiGMUd9JbSFEcp5JCUorrE1LtbzIUEqPOtwUDy60TjHYIQA+2YdDShNOkUGaLMuw1iPFQFaWaF0gYzoVWCw+eISMtF1DmRcIJNYahIjUeY6UKi0cZZoNK6cwQw9SYZ0lk0n+NfQdLhoQEq2zZP31Pn2/BcgYR7dgHJMX+JdbxF/o9eUY4WdVCv/qb0zjBPmVJ8qX04bxoegHisUdtust9a3bLM9OeN43HO0dMTt9jpAdL4Li4NYxy+c9QTq6oef5vGB+5zY8fUowgbXreGIMqiw5ONpn9uKEqzBgKo2NnsG11IsFM/0am+aC1u7ICkUmBGfbNXGqOJjdZX818LK95ESuEVlNpmFW5sRpzfKyJQuGqTrk4bMn1Is9fundv8If/sk/52z3GKkjKvPsL6Z8WJWYiytC0/Ar33wzPcSDo+sGwphg4nygKAqkD6w3W+bTKVVZ0jQte8t9Xp1f8tnD52S5SjySuOHu3XvMJkmx8Cu/+itMJ3MuL9KyemUkQde4sqSe76M6i85L3qjh28cTjmiwqxOenL9EesPBwZJmtWEXPK8ePeLy/Bwpkz5/6DvOLi9omwZBGKljHbFIzZHOMoa+pes72maD95aoJMe3jvmdf/rb2GD54slDptM9/uKv/RrzacFqfcGf/ugxzjnmiwVl/vWM6J9bdL0N9K0nOMhUSZ6VZDppcxFqPNJGBBotylFgnyDOVVWg8xylM5q2o217vA/oInUW3nliACEUXdelhU2MZEqlo6eUWGOQSqXZY/BoVeBC+lwIITEfYkRLnR5QgNI53lkkqaONkQRrDindNelYU8R2P/ysttSO+liExBmDGC2wQgT6viPEiJaOTGXI6EfzQtKeJnOoSPrh4IlSJeWAc8m+S0jpxVKixw7Rx5BO32OhFaQFmlIZXhqkFBRFgfMpwFNpddMcxgBZVmCHDhciIUpKlRF1ivFJsq2QXIPj6w12oKySrI2gUDrHOUemFIPpcTJpsHOVXn/QmlznoDKkiHTGoGQyT8jx5+SsRSLItUa7hN6MjA/8UV+cjhiBXEnKKqOoClSm+NIk/Iu7bjCMQMqF/69WVYy4m690uuJnul8xvidk9DjbE7xh5bZMreEqF7zAciQUbddwlklWXcatusadvuRsotl2ay5cw2uHE4ZXV/gqI2YSryN9FiiWc0rjGOjQGSgluNp1XJQTpgdv8qDZ0O7WPGte4uoCoUr2RM69W29x/mxNHRrmecE0q7hoe6rbh7xXfY+TJw952Vt29hHy9CFueZc7s0NU7Hnz1hF36gVit+FQwvPtmmbdEO2AGSzTec1sOsUMA+thQOuMxXKOtZbe9Bhj0z4iBC4vz3n4+ITlYkkIjsurFQcHhzTNjjffuM/Zqxc8f/KUzabDWcPt+3fYXVnKyS2y/TsEoSmNY1rlvHNnSdm9wnVnPP/sJzx9+pKjg32CcTTrHW3b8uTpCx4+fMjQdcynE+o6Y71N1vxr+uH6as1QWg6O9vDe0rYJtiWFZLl/wKeffczl2QnLxYyirviTH/6QVjS8ePWE33v8GSenZ1jjkVGyN5//a/URP7foOhdZrRpOz3bcOhpYLCeQj0F7UiBlkqyImIqGsZZM9kiVJFF5XiC1HnODkrwmRI8SGmccMQSsSWm3IXjyPEerNKt11qKz7Ib2k+cFQiRylkbhnMG6lPQrhUiLoRDReeIJOBcI3qelTgg3eMpMpaJvnU+x1kIyDI6IINPpc8OIm+yto9Aa53oiqTtUIiJVytDyI1/2WkGQSYhR4YkoAdFbuJYd4RE66YW9S6/dOQ/BJ6K986lDlGluK2KK3cmKAukdUiqUypLkTSli9GilyPMKZ3u0TrwJISWaSJFpcp2lr6uoiMEmKZlW6KgxIRAIOAeZ0oQ8/cySdu/Lh4BUafQhlaaskuogAsZZirLGWUc/DFR6yqyo2IYB50eDRgxjGINAasWsKthb1BwfzJhP6j8TRTdd4ksBwlcTJL/6O/4l2pgUEilFen2SGziUEJKIodA9dV2glaQvFLUIRNfR54IsFmhhkTga4akP9pBDS64k06pi1bXUD26zNA6l07hitVvT5pp6UfKmzSkM/LR5RZ9noPdQpuH4+C2uguClfcRUtuyXr7Es99nulXxj/8/x4icGHWoeX/Rsz/4EROCdvdtMqz368yeUynBU7fPmcp/bkwnnK8glLJwlBkuZZ4SDfZ50Qyq0umdSlUgiRZ5TVQVFVbJardk1LXLkNA9D+v1nFxt2bUuIDi01i8Uei/mCe3fuoqRmuTxk6AcmkzlCeH766BGvzIxtHzg+uA9ljpotKNxA2F7hbcPJky/4/ItHHN26w/sffZOj+/cILpH9msFgQiRqjdeK1gaMgzt3HnD3jbfRRUXbDCiVpV3N0LHdrGm2O8qyTJlzJqmynDOcPX6FIrBanfHbv/0CKQWr1RprHXt7+6mxU/9NzREx4K3jcr3m/GLNclGRF9MkfZJyjCXRN7pL7zxD6BAyof2KomA6nWPdKyKRpm0g0xAMzps0UghpTqWVujEzRACV4sevwd06y0AkqLZWAtN3KKkgpNBGFx0IhUDivcWG5IK7JnMlD70iBo91gXYw5EokRi1gvRuXP2J806XZqL2OMr9WDhAptCZEATo5ta6zsGSIKElKH7hmrYqkWSZGvItkWY4dHWDee0Jw6BE3p1VCRCKTPjptyyp0PnI8hUArTV7UGJcwlXlVo0RKXFbCE6NBq4yyKMjKEkEkz3PwqYNTMsFdsqzAxICQFucdWmucD2RZypRDJYWBUjrlm+U5OUkKFmJEdB0iBvIiR2pN06ypqoqpzrl0Lc4nxnKIAYGgzDJm05J7+1Nev3PIrK7+jKzSrrvdL5XFN1/WzRRE/Ex3e910CJHYC1Kkh50cfwnAmitCnJDbwBPZc5ynwMbP6JlPat7yOb3zPOlWSUpWTzmWFV80J2xMxxWeB/M97raCZ8MJ3l8Q9JRezJjfeZN846ivzkCeUwnJ7eotvrAN5et3eevCITaXdMOMP33yCPv4Y8pC8cuLN3n16gxLC26DyjVdt+ad+Wu0fp9b+zWLYs6dukb7jj0RWRLw/QbvDeC5c7RPVRQ0XceV6XDOkRfJWXn1dENWGvI8Q0pFcI711Yr79++xt3/IT3//j6gnJVrn7C8O+eXv/jn2Dve5d/c22805n33+CU8ePWFveYQxhkHmqL1jMl3Sd1v2FvsYE8kycASarmG1XjGbzPjWt7/N/bffJC8Kzl+95Oz0lLPzC9abLYPtaU3HpKxZTJd84/0P2Ds6piin6EqSZTD0A6bv2a7WSdEz9MntqTOmsxnvv/8Bn3/2KR+89z6D6dluNxhnefL0Ga9OTxlMj1QCpfOvvd9+vk5XC/KJRGeBwbXsmh3VJEdn1RjgN4rco0hSLGdTlyYlWpeURcGkniKESlbi4HDWYcftehobBKQaRxUx3AQn+uBHIE2SR0kBxvYIIekai3cOleubzXjKCJSjWcNDSIs6LTXBJckXMdx0gzEmi7NSqXPzLhVvKcCHgOk75GhEwIT0WBHgQqQoUhaVtBJrUoFUUuEIyckv5JgQnGYeOstxw5AA3jEyWEuWZaPSlaQYUBqlc4ZuS5ZVeJXhbBqvECNy7KZDDGnkIYtkXvABXacFlkhBcEzrCdO6SqmuQlBqRTWd0Pc9UQhkpohkhBjIrxeMBGIAawbKLJ04hICqrJOtVyuEkOyVZXKeIcbZukhEs5hUDGWRI0WPjwHvk7wtEskETHPNoipZlhXzquIrmZC/4CsCPj0gUQQRf7bgXkvJrgusEDd/F2N3e93lJjAO5BomdYmiZMGKZV3juoEqOGI+MBP7+PaKvO4IuWe+OCTbQaUMth7Iq5rFbMZQaubNBpllyLpClfs87DqmiylvzT6kuXxIXt/i4cUVG/8SoRTv791mFiUvdiuC21LkkipWhGi4vdhn155RFlPuThe8tTjmMKtAHWF9jxy2nLWv6NZXlIOjms4pMs1q1/D05StAsZgtuPfgHmIeMKEDb4hB8O779zk5aYjeM52U7JqW4CMXlys++/wpk2mK9bp36z6//hf+AvWkZrGcUxYZz9crNlcrPvrwA/b292najsbC9tJzOfTMippZWbIyLYyju643NJ3ljTfe4O6D+0wXc7ZXV5y+fMXnX3zBi5OXPH/xfEwAr3nj/uv86i99yGtvv8Fifw+hMmL0SBEY+o7L05PEYSkKXr14wfmrl7z73vsc3Trmpz/+U/b2FpyeveLoYI/XHtzh4eNH3Lt7TFmXvDo5paoKsuzrre0/t+iWtWaxLFnuFRS1AOmTY8MDOoFXZNQQRqF7SJ2qt4ESQV3W9HlOURRpgSJVsgIPPdGncDgpBFme451DIFP+11hMMp0TQ6Aoy5TVBVhrcdak5ZtPR/MQ3AjC8QQxdpBjeOD1sizPs5TYKtP23FpHEAEpdNpaxxQxo7NxZCJVKjpFTmeSmoKY8H0hQCAkg4UaZ8wx/TtyTGyIITn0Mq3IlURkKTHYj51fpnOs7RBComUihw0j0EeqtMC0No5vbjXKtBy5LhGCm7mqtRakwtsOGzxVVXF4sI9Wmt56ohTUVcG0moxGCUHUCTqPt4hYpNw5PFiXwiizjLqeUOQZs8kEIVWKSiI5EQ8WkvOry/Tz8Ml4oVWSB6oIudR01oy3RHoNwSVtb9u17NqW9Lz8s9HpXl9fltd/9TMwjtWuO93rAvuV7vfm84wxR0OHzyreWt4mKxYMVeS9IVDP9jlfBaZVyQdkTKpDnqwDV1XkYPIG02FNNdnni/M1RkdeX97loFmgsoKfXO1oaVl1W/zsgNeL1znf9Xhr0DKQy0TNunV0TLsRDHKCF45M5+xVEw4XM6amxseBWgmO65yuvcQ1L+n7EwbX4oNBe836XHD54pK6yNl2PYNxZFqw3jbcvnuPxdGMHz3/NH1vhKTUCxbvfpPL00u0sxQonj07oewih3uHNLsd33j7bf76X/2rRAHD0PHjHzxiu91SFpqqKnny5Amff/GQbbNFKk23eI2+gzN+RF0V7B/eZoage/kZzauXLOspb3zjHaZ7S/CB1dk5r16+ZLVe07Qdw+CY1DV3jo75lV/+Fd7/5occ3DpGZRnGWEL0DMPA1fkZF69eIbI0Hlws9iBGPv7kR7x4+YQYI5eXl/jgado1d2/d4vTVS7KiZDGb4N0eu2Z7k7H3866fX3QnGfNFxf5+zWJRMlnUzJdz8qwkRD96ztUobUpHTx9D0p+KgTwvUUpQVyXepyOcNT1iPHozCs2DT52iDQ4lJCFI1JhHlRX5qEpI3a93No0LpLrRtYYEDEjLr7HjlqTcqzQSUGkuE9MIwfs0JgiRFEFEmglnKhIElGWBdam411pRFyV9NwABSVoeplxLCTLgXVpaKTU+5WJA6VQoM60TP0HFtO0d1RrXb1BB2upbH8lkIDAyFkaThBg3/llRMBhD8ClPTpA8/0qno5ztG4iS/fmS5WyaukiVZsF5XjI4R55luAhVWWE9mE6jpcdHgVIZKkKMgTrPKaRiVk/J8py6mqQZWdshlaTIIov5nNVmg9LgxpOF8x4RAvNiQu/s2O2nNdUweLbrljNA+MB6XaG/nrf038KVVqDcUG++VCZ81QMRR/DPTWG97nIZf0bjCep6DIEA7xrC4MimB+gwUB8sOVbv0a0atpVFiIx99QZuNeBjgxOaMDngQXnEedOSlRYbGja+4+7BbYbLhuVkxlQ5ikwwqwqOj24x7Tpys8EJS12VHJUz3pvfZr5eYmuJjw37Vc296Zx+u0NvOk7OzzB2xaPTLYNpidECCWoVSTsQshzXBaxMqR/ep72D9ZG2Gzi4e4R6oXHR4vHsYk8rPP18j+7qCl0KJgf7yNbw+v3X+JXvfYflfMZiOeFf/IvvY63n/r373L99j6zQ/PEP/4jTiwuyPCfLc66uztmpJWp2hxgN6/U5928ds4yO6BusaXjtzbsc3TokyySbq0suzk5Yr1fsmi3OefYO9nhwa5/vfec7fOvbH7A4PCAvS6xp6XYrmt2O9dWKdtPQdz1RK7rLK7qh5eT0BT/44z/EWsdiNqMoUxbh/6+9M2uOLLuu83eGO2Ym5qGAGru62JxFihrcomzRCj9Zln6A/5F/g5/87DdHOPxgPzlEilIExebU3dVzVQGowoycbuYdz/HDPplA0XKXI2RRDBO7AggkMvPmrcTJffdZe+21Li/O2d/dZWtji5cnx/R6PbIkYjrtcM2bV9yXrvoktfR7YiS4MshZGayyvrmDxTKdjUX5Xwsm5hAcU2476qagnFs0DmMUaRKLpkCQYHRO1Kw65/AIZWqBJSoEW/Qo0RBoOlzXSbLzHmNCdWGEaqaNDnY3DhNJIu86J5CF61BaB4qWou5arIe2dcQaWkAhDa04i8WGp21D8rM0bcNgMGA4mdLUHbENjhRBDKbrvMj7eXkfjDFhuy7iLlZrfCfKSUBIzoY2cH01Ajl0zmGI5CKmDHgxyBP4RS9Hm6UhKUlf+5Y06YvJphNzzCiWY1hrSNAYZYWN0IFNLMZJk8sHrNcpaMuKLO3RaqH4aeXI0kQgk6aj0o0srDyjLksKoOoSVgYrzGYzYpPgvMIBk2KC9zK63QXIQpqGMO0KfNUwvJqKbcpvG2VsOcShXmucLZLozfNdqK8pdZ2I1c3nIQI41jZoN2VlZZ0stuSbm9xZ2SYrhpS6JY8zsqwirgrOaUjSlNVswOasZrUumPo5eZqxmq2yt/eYnWLM2M1JEs8g7/Owv8ValHI2n9Cpmrabk2pFpuZsVjNmTcXV6CUviyEH9Zy2ndH5moWNfOc6fEi0Ik3ZiVaH7zC5wVWaOsBwzjvR/7CGeVmRlxGJ7dE0Q0DWdpL2iNM+ebZG3IGLXvLN/X3+/E/eZTS8xLWiaftgb5fWOc5OXrHxzjskaUxZzdHWsrG5ycXFGcPhEMwF2ua0ZcGMmiaLSDcH5KZkcP8O+w/vEqcRzbzg6vSY8eiCeTmjrhu0MWRxwjtPnvDkyWPWN9awEVTzCaOrc06PX3Fy9Iqr4YQ4TumvrTErCsaTEc+efc7R8Uvu7NwnspamFf/Bl8fHzIspx6dnPLi3z9GrIw4PnmGtYaWXYe0/djjCaOJYyv4sy8l6Kf1+n1iltK1jWo3xsmMXupSSpItRtHXLbD6mnnuiyLKxvsrzg1cYa3FNF+hbYe7fe5q2wmgV3A40SZpSl7Kt977BIaaMItWowXe0jVC+nBdcdHG/mB92YbirIzJWlLuUoKjGaNrOo42l6jqhlDUdeQ/xxXIuGDVa6q7DOkcaR3R1jVZgrVjBixKBRitH04prrtEabxUuiH0bpem0DxNmfknCr9s2VLPyyXWuk+kzFM41eAXWClshsglaS7LUyLG6dsE4Fp1a19ToNMUGNoc1hrp1RLFFa0MWyeuqzqFNRGQcUZrSOEeSiBaGthbamiy22MjS7+VEUUJVNxSzmdj3DFZJe330cMR0pumaTnBnbcTg0miuyik9F+G7ls45lBPsvuyE00knWsALyOifNdSNr0V1GwY3lvoLyqP1gqVwLXBOqHZ1oJld03VD4vXgTIfxBZ0riElJaNm+u8dWvcGwKvCRYef+gHvTkuPZhNI3ZEnC3fsDHpYVV+UEExnSJGLbJtxrUobzgun8kmp+wvnoMy6amrKuKOu5MG26Bu87+Sw5t/z8eN/JFw7nXRhyWSRaF1y/OzrX4r0myTRr2S5Xh1ehqBIyeRLH0mfoYgbZKkV9hVMKpQ3bK+tEugfjKXZ4xd2vPOJrb79NFhsKq3n4+G3KYsb52QlJpOj3LLNyzAcfP+P87IRxMWc4vGA2K6RBPrmki3PaqEd9OmcaK9pql621lK29XdJ+ynw2pRgOubo4oawKmq6h6WT6dH11jZ2tbfr9PuCZT4ZMR2NOX53w4uCQ86shnVOsbiTE3jOdz5lMx1R1SRwlPLh7j93dbV4dH/LJp5+SZzmj0YQPPv0cZRS9fs7ockY9m9Pf3JDBqDfEl48BW0Mcx2Rpn36+Shr3sZElsRlpmjGrJnjXgpIGlAIa5fBaHFarsmAyqdBB9tE5R2wtVVejUVIhyoQASknD3DtpFJkAP/jOSVXpveChWovTr3N41wb8MxYJRy1eSs45EVVBruRWK5S2UokqqSq10tR1TRQnVE1F6zrqxqMRCCKKLEp7tNdhoSWUpsThaVonladWeDq6FpQRR2AF0ApNJYpilHfY8OaIyLpocGnvUdrI1lx74Sz70ORzIsTTOidJ1Bhwgk93bRfWfof2IkuZpDldI5VJL83RRnYJNjThFuNUbdvgHdisT9c2xDahtg3O1SgFadajmDR4bdFRQt04kjQi7yXMZlPK8RVdt0IUR/R6+RKqqeqKPO9TNiL63ilNUc6JvaL1ikAzll2Bc7jOQwe+/W3opInkJIuCYZFwF9CPRpgKxosT8M1qWCu0udlI+/UKWf6mXddwdfmc6egV0XHGaHefXjYQXD6ynEfn0LRkTUPsHfWs5PlJgQpKea2rOC9nPG9LdKhIF3zwa9bFDQL3Qk7TBWF1HISE67z8jBcjThf43M47KT7Cz0ppNla2+YPHf8qvmp/z9JP3SSLhr0zGV3TtnN3dLdFakZILi2ctMtTjOb2u5Xvf+RZb68LZ1UYkWd//+Xt0najtKWMomoof/4//RjGd0euJBkKvnxPFhqpq8C3Q1AwGm6ylOXE3Z5WGjbUd0kGPrusYnZxzevyS8+EF46KgrBuUNlil2N3cJImFuz+fjpgMp5ydnPHy+JSjkzMaB1GSsKKkH7WxucnHH/1KpFcjQ5ZnTEdDiskIY0Arx2Q65+SsABx3t9dZXelTVyXFZPKPHwOO45hBf421wRZZuo7VyVKC0RgR2F5YDi8qBO3Ba+FlytW0I04sKsjedW2LNsgAgnfQiTW31QqNxxuLCQs+SRM80phoXIf3i+27x6BofYdrW/KsB85jopi6rsB7jInC4rFoFDZMQvkwURTZiKZtiOOYoijAWJqmEXcJJW7CSjkI+FYSx6RJIuOOTlTCrBHYoguwggkcYBfEcmIb0XW1COh0AnOoG+paXoPrkPdGy1CJNjY0AeVDLUyLFodBG03bSrXhnaP1XiQvQ9Vsw3hx50F3cuGzSni/xkRY42l9J41CGxG1YtnjvQjfdK2jP1jHtTUOQ9W22Kom72X0+wPG4xHFeEici8lflvVo2442XPw2+1uMjKHzsNltcHJ5HMwn/VKhTFTevIwF/19wGv+p4zpJAsrJ1FygLiwgh4UYjoz93vRMu8Zzg1vl8rg3RXAAvGvoaPG+5PBgCF7haQMmHKpplisDi8JoWYviTSGi8IthE+Xdjdk5SZyLR0n16pe3JJFKwnVhJH6hcexxognsHS64R3slqnh7mw/55pPvUQ89Tz/5gLIsMWE832hNWzX4RmFURKIydrL73FUZb72zx+b6gOnogqauiOOIrprz4MFDjFF8/slHTGZTTl6ecXh4iOtga2uHza1tPv70Y9q2pq5L5vOKsnIYm9Ab9FmLPHcHfXbXB/RW+pgoZnhxysHRIaenp4ymYy6GQy4nFc7B1uYmm2srKOWYTyaMzk8ZXU05Pb/k1fkVoyLs3uKIWTlnNp/R7+fcubNHFMWcXZzywYfv82/+7E8Zji8ZDSdM5/Pl+z0aTthe7ZFkEaurq3gMo0nxxjX3pUm3319jkK+TRn0inaKcpZp16E7kGEU5yi0rABAdAI8kBROJDm+kNFFkAke0xTvoXIMKilmdD8R+tRj/FYcIg0y4NVpBIwsmtpa2a1A2wjeN6Ce0jWydteCwnZIttG+F0oST55ooRoXq0bcOEycYa5caB3UXYA8UsUbMLus2uCko4iSGphH/MAdoFdyGLdZI0nPe09Q1cRRUu9D44KeFMkAXZBcJFWCHVhoTGpJSPUsn3QQTSHGQkPPSyuNa4UE73+G1R9dV2CmILgMKsjgBrdBWB1lGJ8MXKGZlQRzn5P0eqpBk37WtNBqx2Dii7Twm0kznczrvWe33WFvfZFZMieOIqqqYtp04K8cJV+Mr2s6xtrEtibhtmPVWcPMpVVXR+QZthb6mtfxNAvj9zxwOMMsNAeFCK1k3vO/qmoOL7kT3+UZlexNekN+9nnABSbIufDb8Aha6duZYSPYuGDcEOqWIHYXCBqnGvb95Ebu+LUlZdk2EpqgPO0Tv5Xg+DML7oMUsZdG1eNGiX5BGPe7vPGRjZYu8nzPo9ZhOp0RxxPpanzyJiazm7upDIlJ2V3a5s7rH/XsPWRn0KIop/cE6vik5ODhEK8W+MZxeXnB6dsL7Hz1lNB4zWFnhwcNHjEZXfPbZpxTTCcV0QhxH9JKUNAJjFbtZxN5Kxlt399je2yXOMspixtnJKQevjrkaTTg9v+T86oqqbdkYrAaJSIerSy7O5gxHlxRFw9VoTlmLSa02hjQVzvhHnzzl8OgZX33nq7z7L77PD//6r2nmU05Pjnlwb5+2Ufzq6VPybIrzJZNxydWwZHdrl3I2BeVI88EbV9yXJt1enJHoBI0Bp+kamE9LmrKlceVS6Frsp1XQ/ZDRTxWq3SRJ6GqwofnlnA8CNh5thUZlTUxoM6GUIjZGeKtBj7U2hhLCFbpbajFoJQlKnH7lQ2ysoasaacQ52U6rgIEa4+m6ljiOqZ0MBNRlidWapvVyEeCafxkZg7VWxIyNoW4txnUYBY0LmFj48DlY0tWU0lgbYw10WBbanF1o6ikf8q8TmTvCdJNC0bU1cZyirRWHCBBGR9cSpTldW4sgetuBkmZb41o88n8T+pwVBofREJkweOLwKqXxwjTQXYuxCUlsqZsapw2urmh8Sd4bUJcFYIjilLrpmNcdvSyi1xc1KWuNTOMEXMigOLs4oa5rVlbWQWuKekbVVFT1nCyL6aUxg15MnFjiWBGb3wb2wo3qFJma1Fovf7OAHpb9tJv83ZBZX5d7fP2YchRJmN6zHB0PT1w+n8Uxg7CODzCHCzDAopG3qFL94vleLhKL5q3zPmCzAat1NzDbRaW7+Ny6kHKX+K6EVpbcrtPNHc+efcLZ+Uu890JPxNM2DaXyjK6uWF3fZie7x/3NfVZ7fcrZlHkxomkczyYT7m5v8vDBI07Pj/nRj3/I8fEJKMXdew+xp8cUxZjnLz6nrWrG46lcEryXSpqG9bUN8nyVzSTna2895v69fXr9jPm84ODgBR9+9JSLyyuuJjMuhhPGxQzvwazJxc9G0vQejcZcDUdMipJ5DU4Z4igmz3PKpiLLMtZWB/zq/RF/83d/y3g04ltf/wbWKD5/9pTLqwseP/oGf/5nP+Do5RE//dnPODo+5+BsyMMH97izd48XB8+ZzqZvXHFfvuq1Wja8XNgit7pDUdO6OS0tWotpoTOahWqqV+BD5WYjjfKefi/BKpg1wdYlyOJ559GRiKYopUWMJYqIogirFU3bSgNJaYEijHBjnZPk5vGBCbGQP9SIIhdoK9sgGyW0TUkY8RJxcxTKWpqqDD5XksC1MSRRJJoOcUTqxLNMLg6GqgJrLHQ1RktCW0g5isIXWC0MB9c0GKPROhYLHe/pAl9Ca710Ilbhm1xEJAFH1iyrd+8Fg9Z40ahwnWRt57DBvbdrG7qmpq4qYmvpEJ8533lMJHBJ50XFLY4i2q4l6mQK0PmOuq6xUUrTiOLbysoaRTGl6xqyLKGYFzgP/V5OEsmGN0kTkansQoXVtRTFBKVlx72zsYOJY9QVaNWysdZna2PA2iBjZdAjjd88vfNPHSokN9mBSAV7He4aYwjbcXm0bOFVEMMPR/o12MEvITe1qJyDBsV1hX/tNrE8HwIMH37rcOils7J67UELo0/8EkggmLdJQ8wHzjjXSRcXtEFCAna+XXLaCQXUar7Nn3znX7OV7fL046d8/tmnGG1ES7ltqZuGOEopq5Y7acp2PiDPMi5HY2bljCjSFJOC7/3+d0njlI8+/CWvTk84ODohyzLSLOfgxXPqtpbJrrqirTviJCIzhqKY4TtPnKWkSc6g1+crD+6zv79D1suoq5qjFy/4+c/f47PPnzOeTnHKMC9rvPMM+n1p9rlGsFblmM9LppMZRdnQeYOymnyQMVhdoaprjg4PGI4u+fZ3fp+f/OQnPP34U4yOeHD/DmeXV5yenfLy+Jx7dx/y6NFb/MH3vsfG4SG/ev8pzw6P2drZZe/eQ46ODt645r7cgr2TPxpOy7SSd7jG4bsG50uUdejECsXEaXRApbQ3QXdVBZGWjjSPiWKLn8qQhCxCh7Gx0KKsDWtJNBQWHfimbYNlDYF25cO+XERkrE3DovFYLZ1kayNQGmu8jMcaS1OFChxH66QZpZxQ1jonydr7hXiNeH3NAi9VYDuhvc2riiiOqZpaOvORcJQ1wvVFGfJ+nzSN6KqKKLagojBg0DAeyfbHWmmHOyV0Mp0YOVcPaZKitKb14ibReU+SZsuxWuNkqqyuG0xbB/5yK+4RTmbdVXCFUFoU17KAYTvvqBsZFe6ihKqqhEcsZRjWaqr5lDxZJ0+zUClBHGd0XSMCOTaRBk/bysj1wvPOaGbFmKZrWFlZw5iIjZUNnG9wbs7+9iZ399bZ2Vgjz1NZG78VIbXogqd7fRuWezelbzw2VL/avcZieL3CVUssGHXtPedv8NNvGmCqACkEBHz5yniCRkVI2ItDI2pzhKTt6ZZwAt4H2tc1DcwjuL0k3EUS7kLV625aiLI12OS773yHB7tPWF/Z4P0P3xMtaGtwTgZilI2JkpzdjS16ecpoUuBwlPOKYtKwv7fFF599TNc5hqMh58MxxkY8evyY8/NTLi/PqWpZu23XCs+/6bBGE0cRq6vrbG/tstpf4+H9R+ztbxPnCY1rOT064ue/+AU/++X7XA4nJElCnKQkSUIvH7A66JGnMW3bcH5+TprElGXFvKqpGsk1VhviNBNjhabj9PiU8WTMvXv3efTgEXU5Z/fODlGWgY5QOmU8mfDpF884OHpJ3su5s7fPn777x7z3s/d49uKQr37lCRsbO29cbeqmw+lt3MbvWtz/TuxvVqmi96sDdCOYn9JacHWtgvCQMEqMMTcm0USDRAdNBr2Yt1gkXgFfhTnA65jvcsAiJFutlLB3lnjvIjELt90vat7g2OyXdDAXLgkLKEHU9ZbKd+5msnWBRhYgCU8Yc455uPaE33/0Lusbezx78Zy/+fH/pJjNhJ3UNOxsb7O/ucUPvv8uW1trXJ6LG8OzF0fcu7dPMRkymxWANLSfHxwyKuasr69zfnFBVc3QwLwSt5UkjVDKMplMWB/k5FnOvbv32N/d5/Gjt9ne2SZOE6Io4vTsFU8/+oRfffAxzw5f0nSOjbU1bBRTty3rK2vcvbPNIE9o5lORIUV4+R6N05Y46ZH0BqxsbuPbjq6aU5YzVlbXuBxeUFUFTV2TxDKJmec9Ef8aDZnPZ2gj3ojjqyu++c1vc3J2znA45PGjh9y7e4//8B//05d2iH8bQLXbuI1/xgiVopdKVqnQ1VdC7VMEZwkVJtd+DR5YYrnev/YY72/ct4ARfPg5wAWLu/XiNNQCOfA4f2NIeon9Xp/zoqJdUMEWxZMk0vYaPljoNbuF8egCKQl9CPz1Py9MhGre8dmnz0iyK07PzzA64fHDRzRVyeGr57x9/z5/9HtfY6VnuLo4ppfn9FPDkwd3GY2HlEVBnudMJhNeHR9RzOaksexo0ZooFnhpdnRMVc3pXE05n+FRtJlmZ+cOd/f2efTgIVs765hEds4Hn33BR598wrOXp4yKOWvrGzRNi1KaOE4w2pKnKYNexvbaKk2ecHp2xnQ2p21lFxdZi4li8tVNotU9dlYztnuWD95/j/d++VP6/R6vXh2RZRl37uxwePiFyBhoTV13WBuz0uvhfcvq6gpHRwckWU5dNRTTkquLyRtX3G3SvY3f8bgJLQSHX7UY2nhdvOSao3v9XH8jed483iJ5LgHa66NcP/LXGnA3H+ZUGL1ZVLksku7iIiF2VotzuMlgcAHjdWHQx3svNEPvWRLN/JJ7JM8P7BiDJVIxcZzw7vf/jCTrc356Ti9K+fjDX9JL4F/+4beJjeLi7JzxeMru7i6+azm/OKGYzQHNxcUl89mcPF1hY2uf8XTM+eUpZSnuMVpH3Lv3gCg+Y1qMGY8roihme3uH7e1ddu/codfPRWmw8Ry/fMXTDz/i2aszxpMpNk5I0pyNOKOua5I4IYlj8jQhiZPw3hqUsgIfhsa+jSLywRrRygZtvsbMxpxcHfLq5IjPP/uMfr+HUoavfe1rHB29oJjNAM/Z+aX0P0KTsq4bsiRlf3+X6fkE7RVvPXjM47fefuOKu026t/E7Hh6vrhOl9CSC2SQ+TD9K8r1Zaf46/itEKx8qXI9wu7jO51w3a5UX6qBePEbuXibwRW5dYsCLQ7jF6wRnZu/R0rUOZLEFhutDldstK+ww+ClJV0lSl2QtTVF5AY3qLOW05fnFc9of/XfefvCA/mCfwdYeV1enfP8Pv4nRHZcXF0DM5uYOvXzAxcU5p8fHaBPz5O23UCpia2uPtc1tzocj/v4Xv2BYtHz3yX0iq+j1Y375yw9YW1+hbmasrGRoJYJKcZJgbcTl1ZA4jhlPhnzx/IAXr045PjlnPq9Y39pCR47Ow9raBoN+P4hLyd9uOpszmxUUVRkonxrnwcY5yeo6Ls7pbMppp2kPTzm7vODu/j2+/uQrNDg+/Ph9ZrOCKEqIo5w0qUXzREnjPkli6kYYF3XZsb/zgG9//Vs8ePvxG1fcbdK9jd/pWNCzFupQi+EEUNcJ8UZcsw38jd9dsyAW2/TXmmEs7nvtlf/B8/n1wnhRwV4n7kWzWXSgl3gsi+r2mpq2qGC9WyRicAuBKJY9uBvnovFOklbbdvzwxz/i+Ref85f/9t+jjWXvzhaumfPq5RU7G5tUjWNzZ5vDF4d89PEnbGys85W3HnJ4cszx6QVnwwv6x+v0+iv80fe+y8PRlMvLMz7+6H1OTw6lKdeIf2CaRiRJjjHiJPPFs4OgUdJyNRxydnnJq9NLroYTOudxl0O2iIL7uCZNU+LIgmsZT4ZMJxOmxZQu6J5YE6E7j0l7tCpm1irmswqnNDurO6z0N6gnl/TyNWbNlDzpcXZ8wfbOBtpoNjbWgq6IoyxLYfvYGO8sezv3+Yt/95fcffyIla2tN66526R7G7/T4f63KQaJJZTwf0iO1xzZ68dI00tKWx+aZT5gwK/btocXeI25cOPQi3PzN/pwofK+TuqK1gfNZq7hh4XAkPeLaTRJtp0XOuKS+abcEttdHGDRTIxsJBodCuZlyWw6pq1nuNYzuppirSdLM54dfMrBq1M2N+6Q5yvcf3CP44sz/vanP6WsWrz/FGtj1jY2ubO7w9HxMW3rGE8mOOeJo5hWBX2XNEE7UEbMKoe+wHtF0zbMq5KzyzGXl2M6D1neI8v6xFFCGickSULTtHRtQ9tWTCZTZtOCtm1J05w4CZOtNsYTMe8Ul5MZl6MKpw1rawkQ8Rd/9Vc8fPyQn/zd3/J73/g2q/0+n37xOd5Z5vMZ06Kgbmra1lNXjiw1fP2bT/hXP/gBX/3WN1jd3Cbv/SOHI27jNv5/j2VFqv6hyvbLFH8X2Kq75vZ6FWCCm5VwtzyWfBce+QJD+DKlNY+wKVQYMRPdBJZF+ALLBYJcaoAU3HVzzDkXoAcVIIbXK/TXboRBnzbYUEUmYqU/oJiOmIxG7Oy+xeHnJ6yvxrw4PODTzz7HeU3Xat5++zEnp6/4u7//GU3r2NvbZDabU5aOl6+OGQ4vSdKE2bwkTyI21noUzjErHSZJsZEm8cLxn5Ul1iR4r7A2pi0rxpOCeVUSJyk2TtjeusPezg6rg76IKZWzYHQwp5jNmc9L8J5+LyLPB2Kiqy2tF8rbxWTEcdmS9td50Xk28hVmTcF//S//ma7suHf/Lo8ePeDl6TEnJ4doDeV8DkrhOoVWMV9/5+t8/90/5q3Hj+gPBsSJeEK+KW4pY7dxG7dxG7/BeLO3xG3cxm3cxm38P4vbpHsbt3Ebt/EbjNukexu3cRu38RuM26R7G7dxG7fxG4zbpHsbt3Ebt/EbjNukexu3cRu38RuM/wVHDXP2+PziqwAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ "[1]:
+
+
+# Copyright 2022 NVIDIA Corporation. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+ 
+
+ This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained BERT transformer from Hugging Face, and running it to test the speedup obtained. +
++ + Requirements + +
++ + Benchmarking + +
++ + Conclusion + +
++ ## 1. Requirements +
+
+ NVIDIA’s NGC provides a PyTorch Docker Container which contains PyTorch and Torch-TensorRT. Starting with version
+
+
+ 22.05-py3
+
+
+ , we can make use of
+
+ latest pytorch
+
+ container to run this notebook.
+
+ Otherwise, you can follow the steps in
+
+
+ notebooks/README
+
+
+ to prepare a Docker container yourself, within which you can run this demo notebook.
+
[2]:
+
+
+!pip install transformers
+
+
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Requirement already satisfied: transformers in /opt/conda/lib/python3.8/site-packages (4.18.0)
+Requirement already satisfied: tqdm>=4.27 in /opt/conda/lib/python3.8/site-packages (from transformers) (4.63.0)
+Requirement already satisfied: regex!=2019.12.17 in /opt/conda/lib/python3.8/site-packages (from transformers) (2022.3.15)
+Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from transformers) (0.5.1)
+Requirement already satisfied: tokenizers!=0.11.3,<0.13,>=0.11.1 in /opt/conda/lib/python3.8/site-packages (from transformers) (0.12.1)
+Requirement already satisfied: numpy>=1.17 in /opt/conda/lib/python3.8/site-packages (from transformers) (1.22.3)
+Requirement already satisfied: sacremoses in /opt/conda/lib/python3.8/site-packages (from transformers) (0.0.49)
+Requirement already satisfied: requests in /opt/conda/lib/python3.8/site-packages (from transformers) (2.27.1)
+Requirement already satisfied: pyyaml>=5.1 in /opt/conda/lib/python3.8/site-packages (from transformers) (6.0)
+Requirement already satisfied: filelock in /opt/conda/lib/python3.8/site-packages (from transformers) (3.6.0)
+Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.8/site-packages (from transformers) (21.3)
+Requirement already satisfied: typing-extensions>=3.7.4.3 in /opt/conda/lib/python3.8/site-packages (from huggingface-hub<1.0,>=0.1.0->transformers) (4.1.1)
+Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging>=20.0->transformers) (3.0.7)
+Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (1.26.8)
+Requirement already satisfied: charset-normalizer~=2.0.0 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (2.0.12)
+Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (2021.10.8)
+Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (3.3)
+Requirement already satisfied: six in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (1.16.0)
+Requirement already satisfied: click in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (8.0.4)
+Requirement already satisfied: joblib in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (1.1.0)
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+
+ [3]:
+
+
+from transformers import BertTokenizer, BertForMaskedLM
+import torch
+import timeit
+import numpy as np
+import torch_tensorrt
+import torch.backends.cudnn as cudnn
+
+ + ## 2. BERT Overview +
++ Transformers comprise a class of deep learning algorithms employing self-attention; broadly speaking, the models learn large matrices of numbers, each element of which denotes how important one component of input data is to another. Since their introduction in 2017, transformers have enjoyed widespread adoption, particularly in natural language processing, but also in computer vision problems. This is largely because they are easier to parallelize than the sequence models which attention +mechanisms were originally designed to augment. +
++ Hugging Face is a company that maintains a huge respository of pre-trained transformer models. The company also provides tools for integrating those models into PyTorch code and running inference with them. +
+
+ One of the most popular transformer models is BERT (Bidirectional Encoder Representations from Transformers). First developed at Google and released in 2018, it has become the backbone of Google’s search engine and a standard benchmark for NLP experiments. BERT was originally trained for next sentence prediction and masked language modeling (MLM), which aims to predict hidden words in sentences. In this notebook, we will use Hugging Face’s
+
+
+ bert-base-uncased
+
+
+ model (BERT’s smallest and
+simplest form, which does not employ text capitalization) for MLM.
+
+ ## 3. Creating TorchScript modules +
+
+ First, create a pretrained BERT tokenizer from the
+
+
+ bert-base-uncased
+
+
+ model
+
[4]:
+
+
+enc = BertTokenizer.from_pretrained('bert-base-uncased')
+
+ + Create dummy inputs to generate a traced TorchScript model later +
+[5]:
+
+
+batch_size = 4
+
+batched_indexed_tokens = [[101, 64]*64]*batch_size
+batched_segment_ids = [[0, 1]*64]*batch_size
+batched_attention_masks = [[1, 1]*64]*batch_size
+
+tokens_tensor = torch.tensor(batched_indexed_tokens)
+segments_tensor = torch.tensor(batched_segment_ids)
+attention_masks_tensor = torch.tensor(batched_attention_masks)
+
+ + Obtain a BERT masked language model from Hugging Face in the (scripted) TorchScript, then use the dummy inputs to trace it +
+[6]:
+
+
+mlm_model_ts = BertForMaskedLM.from_pretrained('bert-base-uncased', torchscript=True)
+traced_mlm_model = torch.jit.trace(mlm_model_ts, [tokens_tensor, segments_tensor, attention_masks_tensor])
+
+
+Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForMaskedLM: ['cls.seq_relationship.bias', 'cls.seq_relationship.weight']
+- This IS expected if you are initializing BertForMaskedLM from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).
+- This IS NOT expected if you are initializing BertForMaskedLM from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).
+
+
+ Define 4 masked sentences, with 1 word in each sentence hidden from the model. Fluent English speakers will probably be able to guess the masked words, but just in case, they are
+
+
+ 'capital'
+
+
+ ,
+
+
+ 'language'
+
+
+ ,
+
+
+ 'innings'
+
+
+ , and
+
+
+ 'mathematics'
+
+
+ .
+
+ Also create a list containing the position of the masked word within each sentence. Given Python’s 0-based indexing convention, the numbers are each higher by 1 than might be expected. This is because the token at index 0 in each sentence is a beginning-of-sentence token, denoted
+
+
+ [CLS]
+
+
+ when entered explicitly.
+
[7]:
+
+
+masked_sentences = ['Paris is the [MASK] of France.',
+ 'The primary [MASK] of the United States is English.',
+ 'A baseball game consists of at least nine [MASK].',
+ 'Topology is a branch of [MASK] concerned with the properties of geometric objects that remain unchanged under continuous transformations.']
+pos_masks = [4, 3, 9, 6]
+
+ + Pass the masked sentences into the (scripted) TorchScript MLM model and verify that the unmasked sentences yield the expected results. +
+
+ Because the sentences are of different lengths, we must specify the
+
+
+ padding
+
+
+ argument in calling our encoder/tokenizer. There are several possible padding strategies, but we’ll use
+
+
+ 'max_length'
+
+
+ padding with
+
+
+ max_length=128
+
+
+ . Later, when we compile an optimized version of the model with Torch-TensorRT, the optimized model will expect inputs of length 128, hence our choice of padding strategy and length here.
+
[8]:
+
+
+encoded_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)
+outputs = mlm_model_ts(**encoded_inputs)
+most_likely_token_ids = [torch.argmax(outputs[0][i, pos, :]) for i, pos in enumerate(pos_masks)]
+unmasked_tokens = enc.decode(most_likely_token_ids).split(' ')
+unmasked_sentences = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens)]
+for sentence in unmasked_sentences:
+ print(sentence)
+
+
+Paris is the capital of France.
+The primary language of the United States is English.
+A baseball game consists of at least nine innings.
+Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.
+
+ + Pass the masked sentences into the traced MLM model and verify that the unmasked sentences yield the expected results. +
+
+ Note the difference in how the
+
+
+ encoded_inputs
+
+
+ are passed into the model in the following cell compared to the previous one. If you examine
+
+
+ encoded_inputs
+
+
+ , you’ll find that it’s a dictionary with 3 keys,
+
+
+ 'input_ids'
+
+
+ ,
+
+
+ 'token_type_ids'
+
+
+ , and
+
+
+ 'attention_mask'
+
+
+ , each with a PyTorch tensor as an associated value. The traced model will accept
+
+
+ **encoded_inputs
+
+
+ as an input, but the Torch-TensorRT-optimized model (to be defined later) will not.
+
[9]:
+
+
+encoded_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)
+outputs = traced_mlm_model(encoded_inputs['input_ids'], encoded_inputs['token_type_ids'], encoded_inputs['attention_mask'])
+most_likely_token_ids = [torch.argmax(outputs[0][i, pos, :]) for i, pos in enumerate(pos_masks)]
+unmasked_tokens = enc.decode(most_likely_token_ids).split(' ')
+unmasked_sentences = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens)]
+for sentence in unmasked_sentences:
+ print(sentence)
+
+
+Paris is the capital of France.
+The primary language of the United States is English.
+A baseball game consists of at least nine innings.
+Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.
+
+ + ## 4. Compiling with Torch-TensorRT +
++ Change the logging level to avoid long printouts +
+[10]:
+
+
+new_level = torch_tensorrt.logging.Level.Error
+torch_tensorrt.logging.set_reportable_log_level(new_level)
+
+ + Compile the model +
+[11]:
+
+
+trt_model = torch_tensorrt.compile(traced_mlm_model,
+ inputs= [torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # input_ids
+ torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # token_type_ids
+ torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32)], # attention_mask
+ enabled_precisions= {torch.float32}, # Run with 32-bit precision
+ workspace_size=2000000000,
+ truncate_long_and_double=True
+)
+
+ + Pass the masked sentences into the compiled model and verify that the unmasked sentences yield the expected results. +
+[12]:
+
+
+enc_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)
+enc_inputs = {k: v.type(torch.int32).cuda() for k, v in enc_inputs.items()}
+output_trt = trt_model(enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])
+most_likely_token_ids_trt = [torch.argmax(output_trt[i, pos, :]) for i, pos in enumerate(pos_masks)]
+unmasked_tokens_trt = enc.decode(most_likely_token_ids_trt).split(' ')
+unmasked_sentences_trt = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens_trt)]
+for sentence in unmasked_sentences_trt:
+ print(sentence)
+
+
+Paris is the capital of France.
+The primary language of the United States is English.
+A baseball game consists of at least nine innings.
+Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.
+
+ + Compile the model again, this time with 16-bit precision +
+[13]:
+
+
+trt_model_fp16 = torch_tensorrt.compile(traced_mlm_model,
+ inputs= [torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # input_ids
+ torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # token_type_ids
+ torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32)], # attention_mask
+ enabled_precisions= {torch.half}, # Run with 16-bit precision
+ workspace_size=2000000000,
+ truncate_long_and_double=True
+)
+
+ + ## 5. Benchmarking +
++ In developing this notebook, we conducted our benchmarking on a single NVIDIA A100 GPU. Your results may differ from those shown, particularly on a different GPU. +
+
+ This function passes the inputs into the model and runs inference
+
+
+ num_loops
+
+
+ times, then returns a list of length containing the amount of time in seconds that each instance of inference took.
+
[14]:
+
+
+def timeGraph(model, input_tensor1, input_tensor2, input_tensor3, num_loops=50):
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(20):
+ features = model(input_tensor1, input_tensor2, input_tensor3)
+
+ torch.cuda.synchronize()
+
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(num_loops):
+ start_time = timeit.default_timer()
+ features = model(input_tensor1, input_tensor2, input_tensor3)
+ torch.cuda.synchronize()
+ end_time = timeit.default_timer()
+ timings.append(end_time - start_time)
+ # print("Iteration {}: {:.6f} s".format(i, end_time - start_time))
+
+ return timings
+
+ + This function prints the number of input batches the model is able to process each second and summary statistics of the model’s latency. +
+[15]:
+
+
+def printStats(graphName, timings, batch_size):
+ times = np.array(timings)
+ steps = len(times)
+ speeds = batch_size / times
+ time_mean = np.mean(times)
+ time_med = np.median(times)
+ time_99th = np.percentile(times, 99)
+ time_std = np.std(times, ddof=0)
+ speed_mean = np.mean(speeds)
+ speed_med = np.median(speeds)
+
+ msg = ("\n%s =================================\n"
+ "batch size=%d, num iterations=%d\n"
+ " Median text batches/second: %.1f, mean: %.1f\n"
+ " Median latency: %.6f, mean: %.6f, 99th_p: %.6f, std_dev: %.6f\n"
+ ) % (graphName,
+ batch_size, steps,
+ speed_med, speed_mean,
+ time_med, time_mean, time_99th, time_std)
+ print(msg)
+
+ [16]:
+
+
+cudnn.benchmark = True
+
+ + Benchmark the (scripted) TorchScript model on GPU +
+[17]:
+
+
+timings = timeGraph(mlm_model_ts.cuda(), enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])
+
+printStats("BERT", timings, batch_size)
+
+
+Warm up ...
+Start timing ...
+
+BERT =================================
+batch size=4, num iterations=50
+ Median text batches/second: 599.1, mean: 597.6
+ Median latency: 0.006677, mean: 0.006693, 99th_p: 0.006943, std_dev: 0.000059
+
+
+ + Benchmark the traced model on GPU +
+[18]:
+
+
+timings = timeGraph(traced_mlm_model.cuda(), enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])
+
+printStats("BERT", timings, batch_size)
+
+
+Warm up ...
+Start timing ...
+
+BERT =================================
+batch size=4, num iterations=50
+ Median text batches/second: 951.2, mean: 951.0
+ Median latency: 0.004205, mean: 0.004206, 99th_p: 0.004256, std_dev: 0.000015
+
+
+ + Benchmark the compiled FP32 model on GPU +
+[19]:
+
+
+timings = timeGraph(trt_model, enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])
+
+printStats("BERT", timings, batch_size)
+
+
+Warm up ...
+Start timing ...
+
+BERT =================================
+batch size=4, num iterations=50
+ Median text batches/second: 1216.9, mean: 1216.4
+ Median latency: 0.003287, mean: 0.003289, 99th_p: 0.003317, std_dev: 0.000007
+
+
+ + Benchmark the compiled FP16 model on GPU +
+[20]:
+
+
+timings = timeGraph(trt_model_fp16, enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])
+
+printStats("BERT", timings, batch_size)
+
+
+Warm up ...
+Start timing ...
+
+BERT =================================
+batch size=4, num iterations=50
+ Median text batches/second: 1776.7, mean: 1771.1
+ Median latency: 0.002251, mean: 0.002259, 99th_p: 0.002305, std_dev: 0.000015
+
+
+ + ## 6. Conclusion +
+
+ In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT for Masked Language Modeling with Hugging Face’s
+
+
+ bert-base-uncased
+
+
+ transformer and testing the performance impact of the optimization. With Torch-TensorRT on an NVIDIA A100 GPU, we observe the speedups indicated below. These acceleration numbers will vary from GPU to GPU (as well as implementation to implementation based on the ops used) and we encorage you to try out latest
+generation of Data center compute cards for maximum acceleration.
+
+ Scripted (GPU): 1.0x Traced (GPU): 1.62x Torch-TensorRT (FP32): 2.14x Torch-TensorRT (FP16): 3.15x +
++ Now it’s time to try Torch-TensorRT on your own model. If you run into any issues, you can fill them at + + https://github.com/NVIDIA/Torch-TensorRT + + . Your involvement will help future development of Torch-TensorRT. +
+[ ]:
+
+
+
+
+ ![](\"https://developer.download.nvidia.com/tesla/notebook_assets/nv_logo_torch_trt_resnet_notebook.png\"){kind=logo}
\n",
+ "\n",
+ "# Masked Language Modeling (MLM) with Hugging Face BERT Transformer"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "83f47edb",
+ "metadata": {},
+ "source": [
+ "## Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained BERT transformer from Hugging Face, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Contents\n",
+ "1. [Requirements](#1)\n",
+ "2. [BERT Overview](#2)\n",
+ "3. [Creating TorchScript modules](#3)\n",
+ "4. [Compiling with Torch-TensorRT](#4)\n",
+ "5. [Benchmarking](#5)\n",
+ "6. [Conclusion](#6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "596fa151",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "NVIDIA's NGC provides a PyTorch Docker Container which contains PyTorch and Torch-TensorRT. Starting with version `22.05-py3`, we can make use of [latest pytorch](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch) container to run this notebook.\n",
+ "\n",
+ "Otherwise, you can follow the steps in `notebooks/README` to prepare a Docker container yourself, within which you can run this demo notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "58e687d1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Requirement already satisfied: transformers in /opt/conda/lib/python3.8/site-packages (4.18.0)\n",
+ "Requirement already satisfied: tqdm>=4.27 in /opt/conda/lib/python3.8/site-packages (from transformers) (4.63.0)\n",
+ "Requirement already satisfied: regex!=2019.12.17 in /opt/conda/lib/python3.8/site-packages (from transformers) (2022.3.15)\n",
+ "Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from transformers) (0.5.1)\n",
+ "Requirement already satisfied: tokenizers!=0.11.3,<0.13,>=0.11.1 in /opt/conda/lib/python3.8/site-packages (from transformers) (0.12.1)\n",
+ "Requirement already satisfied: numpy>=1.17 in /opt/conda/lib/python3.8/site-packages (from transformers) (1.22.3)\n",
+ "Requirement already satisfied: sacremoses in /opt/conda/lib/python3.8/site-packages (from transformers) (0.0.49)\n",
+ "Requirement already satisfied: requests in /opt/conda/lib/python3.8/site-packages (from transformers) (2.27.1)\n",
+ "Requirement already satisfied: pyyaml>=5.1 in /opt/conda/lib/python3.8/site-packages (from transformers) (6.0)\n",
+ "Requirement already satisfied: filelock in /opt/conda/lib/python3.8/site-packages (from transformers) (3.6.0)\n",
+ "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.8/site-packages (from transformers) (21.3)\n",
+ "Requirement already satisfied: typing-extensions>=3.7.4.3 in /opt/conda/lib/python3.8/site-packages (from huggingface-hub<1.0,>=0.1.0->transformers) (4.1.1)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging>=20.0->transformers) (3.0.7)\n",
+ "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (1.26.8)\n",
+ "Requirement already satisfied: charset-normalizer~=2.0.0 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (2.0.12)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (2021.10.8)\n",
+ "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (3.3)\n",
+ "Requirement already satisfied: six in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (1.16.0)\n",
+ "Requirement already satisfied: click in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (8.0.4)\n",
+ "Requirement already satisfied: joblib in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (1.1.0)\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install transformers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "1104c4f1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from transformers import BertTokenizer, BertForMaskedLM\n",
+ "import torch\n",
+ "import timeit\n",
+ "import numpy as np\n",
+ "import torch_tensorrt\n",
+ "import torch.backends.cudnn as cudnn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "acf67a5e",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. BERT Overview\n",
+ "\n",
+ "Transformers comprise a class of deep learning algorithms employing self-attention; broadly speaking, the models learn large matrices of numbers, each element of which denotes how important one component of input data is to another. Since their introduction in 2017, transformers have enjoyed widespread adoption, particularly in natural language processing, but also in computer vision problems. This is largely because they are easier to parallelize than the sequence models which attention mechanisms were originally designed to augment. \n",
+ "\n",
+ "Hugging Face is a company that maintains a huge respository of pre-trained transformer models. The company also provides tools for integrating those models into PyTorch code and running inference with them. \n",
+ "\n",
+ "One of the most popular transformer models is BERT (Bidirectional Encoder Representations from Transformers). First developed at Google and released in 2018, it has become the backbone of Google's search engine and a standard benchmark for NLP experiments. BERT was originally trained for next sentence prediction and masked language modeling (MLM), which aims to predict hidden words in sentences. In this notebook, we will use Hugging Face's `bert-base-uncased` model (BERT's smallest and simplest form, which does not employ text capitalization) for MLM."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "19e711c0",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Creating TorchScript modules "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81d4c6f6",
+ "metadata": {},
+ "source": [
+ "First, create a pretrained BERT tokenizer from the `bert-base-uncased` model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "c7c8721e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "enc = BertTokenizer.from_pretrained('bert-base-uncased')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b7c1c679",
+ "metadata": {},
+ "source": [
+ "Create dummy inputs to generate a traced TorchScript model later"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "c3827087",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "batch_size = 4\n",
+ "\n",
+ "batched_indexed_tokens = [[101, 64]*64]*batch_size\n",
+ "batched_segment_ids = [[0, 1]*64]*batch_size\n",
+ "batched_attention_masks = [[1, 1]*64]*batch_size\n",
+ "\n",
+ "tokens_tensor = torch.tensor(batched_indexed_tokens)\n",
+ "segments_tensor = torch.tensor(batched_segment_ids)\n",
+ "attention_masks_tensor = torch.tensor(batched_attention_masks)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e31b27f",
+ "metadata": {},
+ "source": [
+ "Obtain a BERT masked language model from Hugging Face in the (scripted) TorchScript, then use the dummy inputs to trace it"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "a3cd5a35",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForMaskedLM: ['cls.seq_relationship.bias', 'cls.seq_relationship.weight']\n",
+ "- This IS expected if you are initializing BertForMaskedLM from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+ "- This IS NOT expected if you are initializing BertForMaskedLM from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
+ ]
+ }
+ ],
+ "source": [
+ "mlm_model_ts = BertForMaskedLM.from_pretrained('bert-base-uncased', torchscript=True)\n",
+ "traced_mlm_model = torch.jit.trace(mlm_model_ts, [tokens_tensor, segments_tensor, attention_masks_tensor])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d8d2217a",
+ "metadata": {},
+ "source": [
+ "Define 4 masked sentences, with 1 word in each sentence hidden from the model. Fluent English speakers will probably be able to guess the masked words, but just in case, they are `'capital'`, `'language'`, `'innings'`, and `'mathematics'`.\n",
+ "\n",
+ "Also create a list containing the position of the masked word within each sentence. Given Python's 0-based indexing convention, the numbers are each higher by 1 than might be expected. This is because the token at index 0 in each sentence is a beginning-of-sentence token, denoted `[CLS]` when entered explicitly. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "4d1af982",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "masked_sentences = ['Paris is the [MASK] of France.', \n",
+ " 'The primary [MASK] of the United States is English.', \n",
+ " 'A baseball game consists of at least nine [MASK].', \n",
+ " 'Topology is a branch of [MASK] concerned with the properties of geometric objects that remain unchanged under continuous transformations.']\n",
+ "pos_masks = [4, 3, 9, 6]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4d89b4c8",
+ "metadata": {},
+ "source": [
+ "Pass the masked sentences into the (scripted) TorchScript MLM model and verify that the unmasked sentences yield the expected results. \n",
+ "\n",
+ "Because the sentences are of different lengths, we must specify the `padding` argument in calling our encoder/tokenizer. There are several possible padding strategies, but we'll use `'max_length'` padding with `max_length=128`. Later, when we compile an optimized version of the model with Torch-TensorRT, the optimized model will expect inputs of length 128, hence our choice of padding strategy and length here. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d2d7546b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Paris is the capital of France.\n",
+ "The primary language of the United States is English.\n",
+ "A baseball game consists of at least nine innings.\n",
+ "Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.\n"
+ ]
+ }
+ ],
+ "source": [
+ "encoded_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)\n",
+ "outputs = mlm_model_ts(**encoded_inputs)\n",
+ "most_likely_token_ids = [torch.argmax(outputs[0][i, pos, :]) for i, pos in enumerate(pos_masks)]\n",
+ "unmasked_tokens = enc.decode(most_likely_token_ids).split(' ')\n",
+ "unmasked_sentences = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens)]\n",
+ "for sentence in unmasked_sentences:\n",
+ " print(sentence)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b0b423ff",
+ "metadata": {},
+ "source": [
+ "Pass the masked sentences into the traced MLM model and verify that the unmasked sentences yield the expected results. \n",
+ "\n",
+ "Note the difference in how the `encoded_inputs` are passed into the model in the following cell compared to the previous one. If you examine `encoded_inputs`, you'll find that it's a dictionary with 3 keys, `'input_ids'`, `'token_type_ids'`, and `'attention_mask'`, each with a PyTorch tensor as an associated value. The traced model will accept `**encoded_inputs` as an input, but the Torch-TensorRT-optimized model (to be defined later) will not. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "683a4a73",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Paris is the capital of France.\n",
+ "The primary language of the United States is English.\n",
+ "A baseball game consists of at least nine innings.\n",
+ "Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.\n"
+ ]
+ }
+ ],
+ "source": [
+ "encoded_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)\n",
+ "outputs = traced_mlm_model(encoded_inputs['input_ids'], encoded_inputs['token_type_ids'], encoded_inputs['attention_mask'])\n",
+ "most_likely_token_ids = [torch.argmax(outputs[0][i, pos, :]) for i, pos in enumerate(pos_masks)]\n",
+ "unmasked_tokens = enc.decode(most_likely_token_ids).split(' ')\n",
+ "unmasked_sentences = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens)]\n",
+ "for sentence in unmasked_sentences:\n",
+ " print(sentence)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a31b545",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 4. Compiling with Torch-TensorRT"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "413d8b4f",
+ "metadata": {},
+ "source": [
+ "Change the logging level to avoid long printouts"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "42862893",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_level = torch_tensorrt.logging.Level.Error\n",
+ "torch_tensorrt.logging.set_reportable_log_level(new_level)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "121d6d59",
+ "metadata": {},
+ "source": [
+ "Compile the model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "eab90150",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trt_model = torch_tensorrt.compile(traced_mlm_model, \n",
+ " inputs= [torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # input_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # token_type_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32)], # attention_mask\n",
+ " enabled_precisions= {torch.float32}, # Run with 32-bit precision\n",
+ " workspace_size=2000000000,\n",
+ " truncate_long_and_double=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a96751ce",
+ "metadata": {},
+ "source": [
+ "Pass the masked sentences into the compiled model and verify that the unmasked sentences yield the expected results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "097ea381",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Paris is the capital of France.\n",
+ "The primary language of the United States is English.\n",
+ "A baseball game consists of at least nine innings.\n",
+ "Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.\n"
+ ]
+ }
+ ],
+ "source": [
+ "enc_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)\n",
+ "enc_inputs = {k: v.type(torch.int32).cuda() for k, v in enc_inputs.items()}\n",
+ "output_trt = trt_model(enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "most_likely_token_ids_trt = [torch.argmax(output_trt[i, pos, :]) for i, pos in enumerate(pos_masks)] \n",
+ "unmasked_tokens_trt = enc.decode(most_likely_token_ids_trt).split(' ')\n",
+ "unmasked_sentences_trt = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens_trt)]\n",
+ "for sentence in unmasked_sentences_trt:\n",
+ " print(sentence)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a398271d",
+ "metadata": {},
+ "source": [
+ "Compile the model again, this time with 16-bit precision"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "a063dee2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trt_model_fp16 = torch_tensorrt.compile(traced_mlm_model, \n",
+ " inputs= [torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # input_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # token_type_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32)], # attention_mask\n",
+ " enabled_precisions= {torch.half}, # Run with 16-bit precision\n",
+ " workspace_size=2000000000,\n",
+ " truncate_long_and_double=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a926334a",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 5. Benchmarking\n",
+ "\n",
+ "In developing this notebook, we conducted our benchmarking on a single NVIDIA A100 GPU. Your results may differ from those shown, particularly on a different GPU."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "976c6fb9",
+ "metadata": {},
+ "source": [
+ "This function passes the inputs into the model and runs inference `num_loops` times, then returns a list of length containing the amount of time in seconds that each instance of inference took."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "b72a091e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def timeGraph(model, input_tensor1, input_tensor2, input_tensor3, num_loops=50):\n",
+ " print(\"Warm up ...\")\n",
+ " with torch.no_grad():\n",
+ " for _ in range(20):\n",
+ " features = model(input_tensor1, input_tensor2, input_tensor3)\n",
+ "\n",
+ " torch.cuda.synchronize()\n",
+ "\n",
+ " print(\"Start timing ...\")\n",
+ " timings = []\n",
+ " with torch.no_grad():\n",
+ " for i in range(num_loops):\n",
+ " start_time = timeit.default_timer()\n",
+ " features = model(input_tensor1, input_tensor2, input_tensor3)\n",
+ " torch.cuda.synchronize()\n",
+ " end_time = timeit.default_timer()\n",
+ " timings.append(end_time - start_time)\n",
+ " # print(\"Iteration {}: {:.6f} s\".format(i, end_time - start_time))\n",
+ "\n",
+ " return timings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0b44dcf8",
+ "metadata": {},
+ "source": [
+ "This function prints the number of input batches the model is able to process each second and summary statistics of the model's latency."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "2ef71ab7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def printStats(graphName, timings, batch_size):\n",
+ " times = np.array(timings)\n",
+ " steps = len(times)\n",
+ " speeds = batch_size / times\n",
+ " time_mean = np.mean(times)\n",
+ " time_med = np.median(times)\n",
+ " time_99th = np.percentile(times, 99)\n",
+ " time_std = np.std(times, ddof=0)\n",
+ " speed_mean = np.mean(speeds)\n",
+ " speed_med = np.median(speeds)\n",
+ "\n",
+ " msg = (\"\\n%s =================================\\n\"\n",
+ " \"batch size=%d, num iterations=%d\\n\"\n",
+ " \" Median text batches/second: %.1f, mean: %.1f\\n\"\n",
+ " \" Median latency: %.6f, mean: %.6f, 99th_p: %.6f, std_dev: %.6f\\n\"\n",
+ " ) % (graphName,\n",
+ " batch_size, steps,\n",
+ " speed_med, speed_mean,\n",
+ " time_med, time_mean, time_99th, time_std)\n",
+ " print(msg)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "afe97b9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cudnn.benchmark = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eba98b24",
+ "metadata": {},
+ "source": [
+ "Benchmark the (scripted) TorchScript model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "bab5fa8f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 599.1, mean: 597.6\n",
+ " Median latency: 0.006677, mean: 0.006693, 99th_p: 0.006943, std_dev: 0.000059\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(mlm_model_ts.cuda(), enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc79c452",
+ "metadata": {},
+ "source": [
+ "Benchmark the traced model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "5c0bd8e9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 951.2, mean: 951.0\n",
+ " Median latency: 0.004205, mean: 0.004206, 99th_p: 0.004256, std_dev: 0.000015\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(traced_mlm_model.cuda(), enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "41db22a1",
+ "metadata": {},
+ "source": [
+ "Benchmark the compiled FP32 model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "ade7b508",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 1216.9, mean: 1216.4\n",
+ " Median latency: 0.003287, mean: 0.003289, 99th_p: 0.003317, std_dev: 0.000007\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(trt_model, enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "57b696de",
+ "metadata": {},
+ "source": [
+ "Benchmark the compiled FP16 model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "f61b83fd",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 1776.7, mean: 1771.1\n",
+ " Median latency: 0.002251, mean: 0.002259, 99th_p: 0.002305, std_dev: 0.000015\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(trt_model_fp16, enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "43f67ba3",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 6. Conclusion\n",
+ "\n",
+ "In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT for Masked Language Modeling with Hugging Face's `bert-base-uncased` transformer and testing the performance impact of the optimization. With Torch-TensorRT on an NVIDIA A100 GPU, we observe the speedups indicated below. These acceleration numbers will vary from GPU to GPU (as well as implementation to implementation based on the ops used) and we encorage you to try out latest generation of Data center compute cards for maximum acceleration.\n",
+ "\n",
+ "Scripted (GPU): 1.0x\n",
+ "Traced (GPU): 1.62x\n",
+ "Torch-TensorRT (FP32): 2.14x\n",
+ "Torch-TensorRT (FP16): 3.15x\n",
+ "\n",
+ "### What's next\n",
+ "Now it's time to try Torch-TensorRT on your own model. If you run into any issues, you can fill them at https://github.com/NVIDIA/Torch-TensorRT. Your involvement will help future development of Torch-TensorRT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ebd152d",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/v1.1.1/_notebooks/Resnet50-example.html b/docs/v1.1.1/_notebooks/Resnet50-example.html
new file mode 100644
index 0000000000..36f2f0ad39
--- /dev/null
+++ b/docs/v1.1.1/_notebooks/Resnet50-example.html
@@ -0,0 +1,2018 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ [1]:
+
+
+# Copyright 2019 NVIDIA Corporation. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+
+
+ In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the +best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch’s JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new +world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference. +
++ When deploying on NVIDIA GPUs TensorRT, NVIDIA’s Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA’s Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that +perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device. +
++ Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch. +
++ This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained ResNet-50 network, and running it to test the speedup obtained. +
++ + Requirements + +
++ + Conclusion + +
+[2]:
+
+
+!nvidia-smi
+!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org
+
+
+Tue Feb 8 19:16:53 2022
++-----------------------------------------------------------------------------+
+| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |
+|-------------------------------+----------------------+----------------------+
+| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
+| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
+| | | MIG M. |
+|===============================+======================+======================|
+| 0 NVIDIA GeForce ... On | 00000000:65:00.0 Off | N/A |
+| 30% 29C P8 15W / 350W | 0MiB / 24576MiB | 0% Default |
+| | | N/A |
++-------------------------------+----------------------+----------------------+
+
++-----------------------------------------------------------------------------+
+| Processes: |
+| GPU GI CI PID Type Process name GPU Memory |
+| ID ID Usage |
+|=============================================================================|
+| No running processes found |
++-----------------------------------------------------------------------------+
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Collecting ipywidgets
+ Downloading ipywidgets-7.6.5-py2.py3-none-any.whl (121 kB)
+ |████████████████████████████████| 121 kB 5.3 MB/s eta 0:00:01
+Requirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)
+Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.7.0)
+Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)
+Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (7.31.0)
+Collecting jupyterlab-widgets>=1.0.0
+ Downloading jupyterlab_widgets-1.0.2-py3-none-any.whl (243 kB)
+ |████████████████████████████████| 243 kB 2.6 MB/s eta 0:00:01
+Collecting widgetsnbextension~=3.5.0
+ Downloading widgetsnbextension-3.5.2-py2.py3-none-any.whl (1.6 MB)
+ |████████████████████████████████| 1.6 MB 3.5 MB/s eta 0:00:01
+Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)
+Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)
+Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)
+Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)
+Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)
+Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)
+Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)
+Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)
+Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)
+Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.0)
+Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.24)
+Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)
+Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)
+Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.1)
+Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)
+Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)
+Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)
+Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)
+Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)
+Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)
+Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)
+Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)
+Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)
+Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)
+Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)
+Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)
+Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)
+Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.5.0->ipywidgets) (6.4.1)
+Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.8.0)
+Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.3)
+Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3.0)
+Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.13.0)
+Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.12.1)
+Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (6.4.0)
+Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.2.0)
+Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.15.0)
+Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.21)
+Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.0.1)
+Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.1.2)
+Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.7.1)
+Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (4.1.0)
+Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.10)
+Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.0)
+Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.5.0)
+Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.8.4)
+Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3)
+Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.1)
+Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.6)
+Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets
+Successfully installed ipywidgets-7.6.5 jupyterlab-widgets-1.0.2 widgetsnbextension-3.5.2
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+
+ + ## 1. Requirements +
++ NVIDIA’s NGC provides PyTorch Docker Container which contains PyTorch and Torch-TensorRT. We can make use of + + latest pytorch + + container to run this notebook. +
+
+ Otherwise, you can follow the steps in
+
+
+ notebooks/README
+
+
+ to prepare a Docker container yourself, within which you can run this demo notebook.
+
+ ## 2. ResNet-50 Overview +
++ PyTorch has a model repository called the PyTorch Hub, which is a source for high quality implementations of common models. We can get our ResNet-50 model from there pretrained on ImageNet. +
++ This ResNet-50 model is based on the + + Deep Residual Learning for Image Recognition + + paper, which describes ResNet as “a method for detecting objects in images using a single deep neural network”. The input size is fixed to 32x32. +
+
+ 
+
+ ## 3. Running the model without optimizations +
+
+ PyTorch has a model repository called
+
+
+ timm
+
+
+ , which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet.
+
[3]:
+
+
+import torch
+import torchvision
+
+torch.hub._validate_not_a_forked_repo=lambda a,b,c: True
+
+resnet50_model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True)
+resnet50_model.eval()
+
+
+Downloading: "https://github.com/pytorch/vision/archive/v0.10.0.zip" to /root/.cache/torch/hub/v0.10.0.zip
+Downloading: "https://download.pytorch.org/models/resnet50-0676ba61.pth" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth
+
+ [3]:
+
+
+ResNet(
+ (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
+ (layer1): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (layer2): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
+ (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (3): Bottleneck(
+ (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (layer3): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
+ (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (3): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (4): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (5): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (layer4): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
+ (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
+ (fc): Linear(in_features=2048, out_features=1000, bias=True)
+)
+
+ + With our model loaded, let’s proceed to downloading some images! +
+[4]:
+
+
+!mkdir -p ./data
+!wget -O ./data/img0.JPG "https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630"
+!wget -O ./data/img1.JPG "https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg"
+!wget -O ./data/img2.JPG "https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg"
+!wget -O ./data/img3.JPG "https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg"
+
+!wget -O ./data/imagenet_class_index.json "https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json"
+
+
+--2022-02-08 19:17:19-- https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630
+Resolving d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)... 18.65.227.99, 18.65.227.37, 18.65.227.223, ...
+Connecting to d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)|18.65.227.99|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 24112 (24K) [image/jpeg]
+Saving to: ‘./data/img0.JPG’
+
+./data/img0.JPG 100%[===================>] 23.55K --.-KB/s in 0.002s
+
+2022-02-08 19:17:19 (14.6 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]
+
+--2022-02-08 19:17:19-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg
+Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117
+Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 452718 (442K) [image/jpeg]
+Saving to: ‘./data/img1.JPG’
+
+./data/img1.JPG 100%[===================>] 442.11K 2.40MB/s in 0.2s
+
+2022-02-08 19:17:19 (2.40 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]
+
+--2022-02-08 19:17:20-- https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg
+Resolving www.artis.nl (www.artis.nl)... 94.75.225.20
+Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 361413 (353K) [image/jpeg]
+Saving to: ‘./data/img2.JPG’
+
+./data/img2.JPG 100%[===================>] 352.94K 366KB/s in 1.0s
+
+2022-02-08 19:17:24 (366 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]
+
+--2022-02-08 19:17:24-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg
+Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.18.201.107, 104.18.202.107, 2606:4700::6812:ca6b, ...
+Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.201.107|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 94328 (92K) [image/jpeg]
+Saving to: ‘./data/img3.JPG’
+
+./data/img3.JPG 100%[===================>] 92.12K --.-KB/s in 0.005s
+
+2022-02-08 19:17:25 (16.8 MB/s) - ‘./data/img3.JPG’ saved [94328/94328]
+
+--2022-02-08 19:17:25-- https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json
+Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.217.41.222
+Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.217.41.222|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 35363 (35K) [application/octet-stream]
+Saving to: ‘./data/imagenet_class_index.json’
+
+./data/imagenet_cla 100%[===================>] 34.53K --.-KB/s in 0.07s
+
+2022-02-08 19:17:26 (481 KB/s) - ‘./data/imagenet_class_index.json’ saved [35363/35363]
+
+
+
+ All pre-trained models expect input images normalized in the same way, i.e. mini-batches of 3-channel RGB images of shape
+
+
+ (3
+
+
+ x
+
+
+ H
+
+
+ x
+
+
+ W)
+
+
+ , where
+
+
+ H
+
+
+ and
+
+
+ W
+
+
+ are expected to be at least
+
+
+ 224
+
+
+ . The images have to be loaded in to a range of
+
+
+ [0,
+
+
+ 1]
+
+
+ and then normalized using
+
+
+ mean
+
+
+ =
+
+
+ [0.485,
+
+
+ 0.456,
+
+
+ 0.406]
+
+
+ and
+
+
+ std
+
+
+ =
+
+
+ [0.229,
+
+
+ 0.224,
+
+
+ 0.225]
+
+
+ .
+
+ Here’s a sample execution. +
+[5]:
+
+
+from PIL import Image
+from torchvision import transforms
+import matplotlib.pyplot as plt
+import json
+
+fig, axes = plt.subplots(nrows=2, ncols=2)
+
+for i in range(4):
+ img_path = './data/img%d.JPG'%i
+ img = Image.open(img_path)
+ preprocess = transforms.Compose([
+ transforms.Resize(256),
+ transforms.CenterCrop(224),
+ transforms.ToTensor(),
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ])
+ input_tensor = preprocess(img)
+ plt.subplot(2,2,i+1)
+ plt.imshow(img)
+ plt.axis('off')
+
+# loading labels
+with open("./data/imagenet_class_index.json") as json_file:
+ d = json.load(json_file)
+
+ 
+
+ Throughout this tutorial, we will be making use of some utility functions;
+
+
+ rn50_preprocess
+
+
+ for preprocessing input images,
+
+
+ predict
+
+
+ to use the model for prediction and
+
+
+ benchmark
+
+
+ to benchmark the inference. You do not need to understand/go through these utilities to make use of Torch TensorRT, but are welecomed to do so if you choose.
+
[6]:
+
+
+import numpy as np
+import time
+import torch.backends.cudnn as cudnn
+cudnn.benchmark = True
+
+def rn50_preprocess():
+ preprocess = transforms.Compose([
+ transforms.Resize(256),
+ transforms.CenterCrop(224),
+ transforms.ToTensor(),
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ])
+ return preprocess
+
+# decode the results into ([predicted class, description], probability)
+def predict(img_path, model):
+ img = Image.open(img_path)
+ preprocess = rn50_preprocess()
+ input_tensor = preprocess(img)
+ input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
+
+ # move the input and model to GPU for speed if available
+ if torch.cuda.is_available():
+ input_batch = input_batch.to('cuda')
+ model.to('cuda')
+
+ with torch.no_grad():
+ output = model(input_batch)
+ # Tensor of shape 1000, with confidence scores over Imagenet's 1000 classes
+ sm_output = torch.nn.functional.softmax(output[0], dim=0)
+
+ ind = torch.argmax(sm_output)
+ return d[str(ind.item())], sm_output[ind] #([predicted class, description], probability)
+
+def benchmark(model, input_shape=(1024, 1, 224, 224), dtype='fp32', nwarmup=50, nruns=10000):
+ input_data = torch.randn(input_shape)
+ input_data = input_data.to("cuda")
+ if dtype=='fp16':
+ input_data = input_data.half()
+
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(nwarmup):
+ features = model(input_data)
+ torch.cuda.synchronize()
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(1, nruns+1):
+ start_time = time.time()
+ features = model(input_data)
+ torch.cuda.synchronize()
+ end_time = time.time()
+ timings.append(end_time - start_time)
+ if i%10==0:
+ print('Iteration %d/%d, ave batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))
+
+ print("Input shape:", input_data.size())
+ print("Output features size:", features.size())
+ print('Average batch time: %.2f ms'%(np.mean(timings)*1000))
+
+ + With the model downloaded and the util functions written, let’s just quickly see some predictions, and benchmark the model in its current un-optimized state. +
+[7]:
+
+
+for i in range(4):
+ img_path = './data/img%d.JPG'%i
+ img = Image.open(img_path)
+
+ pred, prob = predict(img_path, resnet50_model)
+ print('{} - Predicted: {}, Probablility: {}'.format(img_path, pred, prob))
+
+ plt.subplot(2,2,i+1)
+ plt.imshow(img);
+ plt.axis('off');
+ plt.title(pred[1])
+
+
+./data/img0.JPG - Predicted: ['n02110185', 'Siberian_husky'], Probablility: 0.49785590171813965
+./data/img1.JPG - Predicted: ['n01820546', 'lorikeet'], Probablility: 0.6445754766464233
+./data/img2.JPG - Predicted: ['n02481823', 'chimpanzee'], Probablility: 0.9899807572364807
+./data/img3.JPG - Predicted: ['n01749939', 'green_mamba'], Probablility: 0.39485082030296326
+
+ 
+ [8]:
+
+
+# Model benchmark without Torch-TensorRT
+model = resnet50_model.eval().to("cuda")
+benchmark(model, input_shape=(128, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 75.34 ms
+Iteration 20/100, ave batch time 75.33 ms
+Iteration 30/100, ave batch time 75.35 ms
+Iteration 40/100, ave batch time 75.37 ms
+Iteration 50/100, ave batch time 75.38 ms
+Iteration 60/100, ave batch time 75.38 ms
+Iteration 70/100, ave batch time 75.39 ms
+Iteration 80/100, ave batch time 75.39 ms
+Iteration 90/100, ave batch time 75.40 ms
+Iteration 100/100, ave batch time 75.41 ms
+Input shape: torch.Size([128, 3, 224, 224])
+Output features size: torch.Size([128, 1000])
+Average batch time: 75.41 ms
+
+ + ## 4. Accelerating with Torch-TensorRT +
++ Onwards to the next step, accelerating with Torch TensorRT. In these examples we showcase the results for FP32 (single precision) and FP16 (half precision). We do not demonstrat specific tuning, just showcase the simplicity of usage. If you want to learn more about the possible customizations, visit our + + documentation + + . +
+[9]:
+
+
+import torch_tensorrt
+
+# The compiled module will have precision as specified by "op_precision".
+# Here, it will have FP32 precision.
+trt_model_fp32 = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input((128, 3, 224, 224), dtype=torch.float32)],
+ enabled_precisions = torch.float32, # Run with FP32
+ workspace_size = 1 << 22
+)
+
+
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+
+ [10]:
+
+
+# Obtain the average time taken by a batch of input
+benchmark(trt_model_fp32, input_shape=(128, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 41.02 ms
+Iteration 20/100, ave batch time 41.12 ms
+Iteration 30/100, ave batch time 41.22 ms
+Iteration 40/100, ave batch time 41.14 ms
+Iteration 50/100, ave batch time 41.20 ms
+Iteration 60/100, ave batch time 41.20 ms
+Iteration 70/100, ave batch time 41.19 ms
+Iteration 80/100, ave batch time 41.23 ms
+Iteration 90/100, ave batch time 41.20 ms
+Iteration 100/100, ave batch time 41.21 ms
+Input shape: torch.Size([128, 3, 224, 224])
+Output features size: torch.Size([128, 1000])
+Average batch time: 41.21 ms
+
+ [11]:
+
+
+import torch_tensorrt
+
+# The compiled module will have precision as specified by "op_precision".
+# Here, it will have FP16 precision.
+trt_model_fp16 = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input((128, 3, 224, 224), dtype=torch.half)],
+ enabled_precisions = {torch.half}, # Run with FP32
+ workspace_size = 1 << 22
+)
+
+
+
+WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float
+The compiler is going to use the user setting Float16
+This conflict may cause an error at runtime due to partial compilation being enabled and therefore
+compatibility with PyTorch's data type convention is required.
+If you do indeed see errors at runtime either:
+- Remove the dtype spec for x.1
+- Disable partial compilation by setting require_full_compilation to True
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+
+ [13]:
+
+
+# Obtain the average time taken by a batch of input
+benchmark(trt_model_fp16, input_shape=(128, 3, 224, 224), dtype='fp16', nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 14.48 ms
+Iteration 20/100, ave batch time 14.58 ms
+Iteration 30/100, ave batch time 14.72 ms
+Iteration 40/100, ave batch time 14.73 ms
+Iteration 50/100, ave batch time 14.70 ms
+Iteration 60/100, ave batch time 14.79 ms
+Iteration 70/100, ave batch time 14.73 ms
+Iteration 80/100, ave batch time 14.69 ms
+Iteration 90/100, ave batch time 14.68 ms
+Iteration 100/100, ave batch time 14.69 ms
+Input shape: torch.Size([128, 3, 224, 224])
+Output features size: torch.Size([128, 1000])
+Average batch time: 14.69 ms
+
+ + ## 5. Conclusion +
++ In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT for EfficientNet-B0 model and test the performance impact of the optimization. With Torch-TensorRT, we observe a speedup of + + 1.84x + + with FP32, and + + 5.2x + + with FP16 on an NVIDIA 3090 GPU. These acceleration numbers will vary from GPU to GPU(as well as implementation to implementation based on the ops used) and we encorage you to try out latest generation of Data center compute +cards for maximum acceleration. +
++ Now it’s time to try Torch-TensorRT on your own model. If you run into any issues, you can fill them at + + https://github.com/NVIDIA/Torch-TensorRT + + . Your involvement will help future development of Torch-TensorRT. +
+\n",
+ "\n",
+ "# Torch-TensorRT Getting Started - ResNet 50"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained ResNet-50 network, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [ResNet-50 Overview](#2)\n",
+ "1. [Running the model without optimizations](#3)\n",
+ "1. [Accelerating with Torch-TensorRT](#4)\n",
+ "1. [Conclusion](#5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Tue Feb 8 19:16:53 2022 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 NVIDIA GeForce ... On | 00000000:65:00.0 Off | N/A |\n",
+ "| 30% 29C P8 15W / 350W | 0MiB / 24576MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=============================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------+\n",
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting ipywidgets\n",
+ " Downloading ipywidgets-7.6.5-py2.py3-none-any.whl (121 kB)\n",
+ "\u001b[K |████████████████████████████████| 121 kB 5.3 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.7.0)\n",
+ "Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)\n",
+ "Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (7.31.0)\n",
+ "Collecting jupyterlab-widgets>=1.0.0\n",
+ " Downloading jupyterlab_widgets-1.0.2-py3-none-any.whl (243 kB)\n",
+ "\u001b[K |████████████████████████████████| 243 kB 2.6 MB/s eta 0:00:01\n",
+ "\u001b[?25hCollecting widgetsnbextension~=3.5.0\n",
+ " Downloading widgetsnbextension-3.5.2-py2.py3-none-any.whl (1.6 MB)\n",
+ "\u001b[K |████████████████████████████████| 1.6 MB 3.5 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)\n",
+ "Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)\n",
+ "Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)\n",
+ "Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)\n",
+ "Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)\n",
+ "Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)\n",
+ "Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)\n",
+ "Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)\n",
+ "Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.0)\n",
+ "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.24)\n",
+ "Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)\n",
+ "Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.1)\n",
+ "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)\n",
+ "Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)\n",
+ "Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)\n",
+ "Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)\n",
+ "Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)\n",
+ "Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)\n",
+ "Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)\n",
+ "Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)\n",
+ "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)\n",
+ "Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)\n",
+ "Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)\n",
+ "Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.5.0->ipywidgets) (6.4.1)\n",
+ "Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.8.0)\n",
+ "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.3)\n",
+ "Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3.0)\n",
+ "Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.13.0)\n",
+ "Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.12.1)\n",
+ "Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (6.4.0)\n",
+ "Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.2.0)\n",
+ "Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.15.0)\n",
+ "Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.21)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.0.1)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.1.2)\n",
+ "Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.7.1)\n",
+ "Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (4.1.0)\n",
+ "Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.10)\n",
+ "Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.0)\n",
+ "Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.5.0)\n",
+ "Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.8.4)\n",
+ "Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3)\n",
+ "Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.1)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.6)\n",
+ "Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets\n",
+ "Successfully installed ipywidgets-7.6.5 jupyterlab-widgets-1.0.2 widgetsnbextension-3.5.2\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "!nvidia-smi\n",
+ "!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "NVIDIA's NGC provides PyTorch Docker Container which contains PyTorch and Torch-TensorRT. We can make use of [latest pytorch](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch) container to run this notebook.\n",
+ "\n",
+ "Otherwise, you can follow the steps in `notebooks/README` to prepare a Docker container yourself, within which you can run this demo notebook."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. ResNet-50 Overview\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called the PyTorch Hub, which is a source for high quality implementations of common models. We can get our ResNet-50 model from there pretrained on ImageNet.\n",
+ "\n",
+ "### Model Description\n",
+ "\n",
+ "This ResNet-50 model is based on the [Deep Residual Learning for Image Recognition](https://arxiv.org/pdf/1512.03385.pdf) paper, which describes ResNet as “a method for detecting objects in images using a single deep neural network\". The input size is fixed to 32x32.\n",
+ "\n",
+ "![\"alt\"](\"https://pytorch.org/assets/images/resnet.png\")
\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Running the model without optimizations\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called `timm`, which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Downloading: \"https://github.com/pytorch/vision/archive/v0.10.0.zip\" to /root/.cache/torch/hub/v0.10.0.zip\n",
+ "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a7036a6122874340b14aaef7b8319260",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " 0%| | 0.00/97.8M [00:00] 23.55K --.-KB/s in 0.002s \n",
+ "\n",
+ "2022-02-08 19:17:19 (14.6 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]\n",
+ "\n",
+ "--2022-02-08 19:17:19-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\n",
+ "Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117\n",
+ "Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 452718 (442K) [image/jpeg]\n",
+ "Saving to: ‘./data/img1.JPG’\n",
+ "\n",
+ "./data/img1.JPG 100%[===================>] 442.11K 2.40MB/s in 0.2s \n",
+ "\n",
+ "2022-02-08 19:17:19 (2.40 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]\n",
+ "\n",
+ "--2022-02-08 19:17:20-- https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\n",
+ "Resolving www.artis.nl (www.artis.nl)... 94.75.225.20\n",
+ "Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 361413 (353K) [image/jpeg]\n",
+ "Saving to: ‘./data/img2.JPG’\n",
+ "\n",
+ "./data/img2.JPG 100%[===================>] 352.94K 366KB/s in 1.0s \n",
+ "\n",
+ "2022-02-08 19:17:24 (366 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]\n",
+ "\n",
+ "--2022-02-08 19:17:24-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\n",
+ "Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.18.201.107, 104.18.202.107, 2606:4700::6812:ca6b, ...\n",
+ "Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.201.107|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 94328 (92K) [image/jpeg]\n",
+ "Saving to: ‘./data/img3.JPG’\n",
+ "\n",
+ "./data/img3.JPG 100%[===================>] 92.12K --.-KB/s in 0.005s \n",
+ "\n",
+ "2022-02-08 19:17:25 (16.8 MB/s) - ‘./data/img3.JPG’ saved [94328/94328]\n",
+ "\n",
+ "--2022-02-08 19:17:25-- https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\n",
+ "Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.217.41.222\n",
+ "Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.217.41.222|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 35363 (35K) [application/octet-stream]\n",
+ "Saving to: ‘./data/imagenet_class_index.json’\n",
+ "\n",
+ "./data/imagenet_cla 100%[===================>] 34.53K --.-KB/s in 0.07s \n",
+ "\n",
+ "2022-02-08 19:17:26 (481 KB/s) - ‘./data/imagenet_class_index.json’ saved [35363/35363]\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "!mkdir -p ./data\n",
+ "!wget -O ./data/img0.JPG \"https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\"\n",
+ "!wget -O ./data/img1.JPG \"https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\"\n",
+ "!wget -O ./data/img2.JPG \"https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\"\n",
+ "!wget -O ./data/img3.JPG \"https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\"\n",
+ "\n",
+ "!wget -O ./data/imagenet_class_index.json \"https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "All pre-trained models expect input images normalized in the same way,\n",
+ "i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.\n",
+ "The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`\n",
+ "and `std = [0.229, 0.224, 0.225]`.\n",
+ "\n",
+ "Here's a sample execution."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "[1]:
+
+
+# Copyright 2020 NVIDIA Corporation. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+ + Torch-TensorRT is a compiler for PyTorch/TorchScript, targeting NVIDIA GPUs via NVIDIA’s TensorRT Deep Learning Optimizer and Runtime. Unlike PyTorch’s Just-In-Time (JIT) compiler, Torch-TensorRT is an Ahead-of-Time (AOT) compiler, meaning that before you deploy your TorchScript code, you go through an explicit compile step to convert a standard TorchScript program into an module targeting a TensorRT engine. Torch-TensorRT operates as a PyTorch extention and compiles modules that integrate into +the JIT runtime seamlessly. After compilation using the optimized graph should feel no different than running a TorchScript module. You also have access to TensorRT’s suite of configurations at compile time, so you are able to specify operating precision (FP32/FP16/INT8) and other settings for your module. +
++ We highly encorage users to use our NVIDIA’s + + PyTorch container + + to run this notebook. It comes packaged with a host of NVIDIA libraries and optimizations to widely used third party libraries. This container is tested and updated on a monthly cadence! +
++ This notebook has the following sections: 1. + + TL;DR Explanation + + 1. + + Setting up the model + + 1. + + Working with Dynamic shapes in Torch TRT + +
++ torch_tensorrt.Input( min_shape=(1, 224, 224, 3), opt_shape=(1, 512, 512, 3), max_shape=(1, 1024, 1024, 3), dtype=torch.int32 format=torch.channel_last ) … ``` In this example, we are going to use a simple ResNet model to demonstrate the use of the API. We will be using different batch sizes in the example, but you can use the same method to alter any of the dimensions of the tensor. +
+[2]:
+
+
+!nvidia-smi
+!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org
+
+
+Mon May 2 20:40:30 2022
++-----------------------------------------------------------------------------+
+| NVIDIA-SMI 470.57.02 Driver Version: 470.57.02 CUDA Version: 11.6 |
+|-------------------------------+----------------------+----------------------+
+| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
+| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
+| | | MIG M. |
+|===============================+======================+======================|
+| 0 NVIDIA Graphics... On | 00000000:01:00.0 Off | 0 |
+| 41% 51C P0 62W / 200W | 0MiB / 47681MiB | 0% Default |
+| | | Disabled |
++-------------------------------+----------------------+----------------------+
+
++-----------------------------------------------------------------------------+
+| Processes: |
+| GPU GI CI PID Type Process name GPU Memory |
+| ID ID Usage |
+|=============================================================================|
+| No running processes found |
++-----------------------------------------------------------------------------+
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Requirement already satisfied: ipywidgets in /opt/conda/lib/python3.8/site-packages (7.7.0)
+Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)
+Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.3.0)
+Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.13.0)
+Requirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)
+Requirement already satisfied: widgetsnbextension~=3.6.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (3.6.0)
+Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (8.2.0)
+Requirement already satisfied: jupyterlab-widgets>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (1.1.0)
+Requirement already satisfied: psutil in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (5.9.0)
+Requirement already satisfied: tornado>=6.1 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)
+Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (21.3)
+Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.5)
+Requirement already satisfied: matplotlib-inline>=0.1 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)
+Requirement already satisfied: jupyter-client>=6.1.12 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.2.2)
+Requirement already satisfied: debugpy>=1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.6.0)
+Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.1)
+Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)
+Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)
+Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)
+Requirement already satisfied: stack-data in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)
+Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)
+Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)
+Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.29)
+Requirement already satisfied: pygments>=2.4.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.2)
+Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)
+Requirement already satisfied: pyzmq>=22.3 in /opt/conda/lib/python3.8/site-packages (from jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets) (22.3.0)
+Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets) (0.4)
+Requirement already satisfied: python-dateutil>=2.8.2 in /opt/conda/lib/python3.8/site-packages (from jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets) (2.8.2)
+Requirement already satisfied: jupyter-core>=4.9.2 in /opt/conda/lib/python3.8/site-packages (from jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets) (4.9.2)
+Requirement already satisfied: jsonschema>=2.6 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)
+Requirement already satisfied: fastjsonschema in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (2.15.3)
+Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema>=2.6->nbformat>=4.2.0->ipywidgets) (0.18.1)
+Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema>=2.6->nbformat>=4.2.0->ipywidgets) (21.4.0)
+Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema>=2.6->nbformat>=4.2.0->ipywidgets) (5.7.0)
+Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema>=2.6->nbformat>=4.2.0->ipywidgets) (3.8.0)
+Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)
+Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)
+Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.8.2->jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets) (1.16.0)
+Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.6.0->ipywidgets) (6.4.1)
+Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (3.1.1)
+Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.14.1)
+Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.8.0)
+Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.3.0)
+Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (6.5.0)
+Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.13.3)
+Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.2.0)
+Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.15.0)
+Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.21)
+Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.1.1)
+Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.7.1)
+Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.2.2)
+Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.8.4)
+Requirement already satisfied: nbclient>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.6.0)
+Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (5.0.0)
+Requirement already satisfied: tinycss2 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.1.1)
+Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.5.0)
+Requirement already satisfied: beautifulsoup4 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (4.11.1)
+Requirement already satisfied: soupsieve>1.2 in /opt/conda/lib/python3.8/site-packages (from beautifulsoup4->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.3.1)
+Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.1)
+Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->ipykernel>=4.5.1->ipywidgets) (3.0.8)
+Requirement already satisfied: asttokens in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (2.0.5)
+Requirement already satisfied: pure-eval in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.2.2)
+Requirement already satisfied: executing in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.8.3)
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+
+ + In this section, we will: * Get sample data. * Download model from torch hub. * Build simple utility functions +
+[3]:
+
+
+!mkdir -p ./data
+!wget -O ./data/img0.JPG "https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630"
+!wget -O ./data/img1.JPG "https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg"
+!wget -O ./data/img2.JPG "https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg"
+!wget -O ./data/img3.JPG "https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg"
+
+!wget -O ./data/imagenet_class_index.json "https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json"
+
+
+--2022-05-02 20:40:33-- https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630
+Resolving d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)... 18.65.227.37, 18.65.227.99, 18.65.227.223, ...
+Connecting to d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)|18.65.227.37|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 24112 (24K) [image/jpeg]
+Saving to: ‘./data/img0.JPG’
+
+./data/img0.JPG 100%[===================>] 23.55K --.-KB/s in 0.005s
+
+2022-05-02 20:40:33 (4.69 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]
+
+--2022-05-02 20:40:34-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg
+Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117
+Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 452718 (442K) [image/jpeg]
+Saving to: ‘./data/img1.JPG’
+
+./data/img1.JPG 100%[===================>] 442.11K --.-KB/s in 0.02s
+
+2022-05-02 20:40:34 (26.2 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]
+
+--2022-05-02 20:40:34-- https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg
+Resolving www.artis.nl (www.artis.nl)... 94.75.225.20
+Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 361413 (353K) [image/jpeg]
+Saving to: ‘./data/img2.JPG’
+
+./data/img2.JPG 100%[===================>] 352.94K 608KB/s in 0.6s
+
+2022-05-02 20:40:36 (608 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]
+
+--2022-05-02 20:40:37-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg
+Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.18.201.107, 104.18.202.107, 2606:4700::6812:c96b, ...
+Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.201.107|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 90994 (89K) [image/jpeg]
+Saving to: ‘./data/img3.JPG’
+
+./data/img3.JPG 100%[===================>] 88.86K --.-KB/s in 0.006s
+
+2022-05-02 20:40:37 (15.4 MB/s) - ‘./data/img3.JPG’ saved [90994/90994]
+
+--2022-05-02 20:40:37-- https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json
+Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.217.33.238
+Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.217.33.238|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 35363 (35K) [application/octet-stream]
+Saving to: ‘./data/imagenet_class_index.json’
+
+./data/imagenet_cla 100%[===================>] 34.53K --.-KB/s in 0.07s
+
+2022-05-02 20:40:38 (489 KB/s) - ‘./data/imagenet_class_index.json’ saved [35363/35363]
+
+
+ [4]:
+
+
+# visualizing the downloaded images
+
+from PIL import Image
+from torchvision import transforms
+import matplotlib.pyplot as plt
+import json
+
+fig, axes = plt.subplots(nrows=2, ncols=2)
+
+for i in range(4):
+ img_path = './data/img%d.JPG'%i
+ img = Image.open(img_path)
+ preprocess = transforms.Compose([
+ transforms.Resize(256),
+ transforms.CenterCrop(224),
+ transforms.ToTensor(),
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ])
+ input_tensor = preprocess(img)
+ plt.subplot(2,2,i+1)
+ plt.imshow(img)
+ plt.axis('off')
+
+# loading labels
+with open("./data/imagenet_class_index.json") as json_file:
+ d = json.load(json_file)
+
+ 
+ [5]:
+
+
+import torch
+
+torch.hub._validate_not_a_forked_repo=lambda a,b,c: True
+
+resnet50_model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True)
+resnet50_model.eval()
+
+
+Using cache found in /root/.cache/torch/hub/pytorch_vision_v0.10.0
+
+ [5]:
+
+
+ResNet(
+ (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
+ (layer1): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (layer2): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
+ (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (3): Bottleneck(
+ (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (layer3): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
+ (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (3): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (4): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (5): Bottleneck(
+ (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (layer4): Sequential(
+ (0): Bottleneck(
+ (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ (downsample): Sequential(
+ (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
+ (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ )
+ )
+ (1): Bottleneck(
+ (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ (2): Bottleneck(
+ (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+ (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+ (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+ (relu): ReLU(inplace=True)
+ )
+ )
+ (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
+ (fc): Linear(in_features=2048, out_features=1000, bias=True)
+)
+
+ [6]:
+
+
+import numpy as np
+import time
+import torch.backends.cudnn as cudnn
+cudnn.benchmark = True
+
+def rn50_preprocess():
+ preprocess = transforms.Compose([
+ transforms.Resize(256),
+ transforms.CenterCrop(224),
+ transforms.ToTensor(),
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ])
+ return preprocess
+
+# decode the results into ([predicted class, description], probability)
+def predict(img_path, model):
+ img = Image.open(img_path)
+ preprocess = rn50_preprocess()
+ input_tensor = preprocess(img)
+ input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
+
+ # move the input and model to GPU for speed if available
+ if torch.cuda.is_available():
+ input_batch = input_batch.to('cuda')
+ model.to('cuda')
+
+ with torch.no_grad():
+ output = model(input_batch)
+ # Tensor of shape 1000, with confidence scores over Imagenet's 1000 classes
+ sm_output = torch.nn.functional.softmax(output[0], dim=0)
+
+ ind = torch.argmax(sm_output)
+ return d[str(ind.item())], sm_output[ind] #([predicted class, description], probability)
+
+# benchmarking models
+def benchmark(model, input_shape=(1024, 1, 224, 224), dtype='fp32', nwarmup=50, nruns=10000):
+ input_data = torch.randn(input_shape)
+ input_data = input_data.to("cuda")
+ if dtype=='fp16':
+ input_data = input_data.half()
+
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(nwarmup):
+ features = model(input_data)
+ torch.cuda.synchronize()
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(1, nruns+1):
+ start_time = time.time()
+ features = model(input_data)
+ torch.cuda.synchronize()
+ end_time = time.time()
+ timings.append(end_time - start_time)
+ if i%10==0:
+ print('Iteration %d/%d, ave batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))
+ print('Images processed per second=', int(1000*input_shape[0]/(np.mean(timings)*1000)))
+ print("Input shape:", input_data.size())
+ print("Output features size:", features.size())
+ print('Average batch time: %.2f ms'%(np.mean(timings)*1000))
+
+ + Let’s test our util functions on the model we have set up, starting with simple predictions +
+[7]:
+
+
+for i in range(4):
+ img_path = './data/img%d.JPG'%i
+ img = Image.open(img_path)
+
+ pred, prob = predict(img_path, resnet50_model)
+ print('{} - Predicted: {}, Probablility: {}'.format(img_path, pred, prob))
+
+ plt.subplot(2,2,i+1)
+ plt.imshow(img);
+ plt.axis('off');
+ plt.title(pred[1])
+
+
+./data/img0.JPG - Predicted: ['n02110185', 'Siberian_husky'], Probablility: 0.49788108468055725
+./data/img1.JPG - Predicted: ['n01820546', 'lorikeet'], Probablility: 0.6442285180091858
+./data/img2.JPG - Predicted: ['n02481823', 'chimpanzee'], Probablility: 0.9899841547012329
+./data/img3.JPG - Predicted: ['n01749939', 'green_mamba'], Probablility: 0.45675724744796753
+
+ 
+ + Onwards, to benchmarking. +
+[8]:
+
+
+# Model benchmark without Torch-TensorRT
+model = resnet50_model.eval().to("cuda")
+benchmark(model, input_shape=(16, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 10.01 ms
+Images processed per second= 1598
+Iteration 20/100, ave batch time 10.01 ms
+Images processed per second= 1598
+Iteration 30/100, ave batch time 10.21 ms
+Images processed per second= 1566
+Iteration 40/100, ave batch time 10.33 ms
+Images processed per second= 1549
+Iteration 50/100, ave batch time 10.31 ms
+Images processed per second= 1552
+Iteration 60/100, ave batch time 10.25 ms
+Images processed per second= 1560
+Iteration 70/100, ave batch time 10.20 ms
+Images processed per second= 1568
+Iteration 80/100, ave batch time 10.18 ms
+Images processed per second= 1572
+Iteration 90/100, ave batch time 10.16 ms
+Images processed per second= 1574
+Iteration 100/100, ave batch time 10.15 ms
+Images processed per second= 1575
+Input shape: torch.Size([16, 3, 224, 224])
+Output features size: torch.Size([16, 1000])
+Average batch time: 10.15 ms
+
+ [9]:
+
+
+import torch_tensorrt
+
+trt_model_without_ds = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input((32, 3, 224, 224), dtype=torch.float32)],
+ enabled_precisions = torch.float32, # Run with FP32
+ workspace_size = 1 << 33
+)
+
+
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+
+ [10]:
+
+
+benchmark(trt_model_without_ds, input_shape=(32, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 6.10 ms
+Images processed per second= 5242
+Iteration 20/100, ave batch time 6.12 ms
+Images processed per second= 5231
+Iteration 30/100, ave batch time 6.14 ms
+Images processed per second= 5215
+Iteration 40/100, ave batch time 6.14 ms
+Images processed per second= 5207
+Iteration 50/100, ave batch time 6.15 ms
+Images processed per second= 5202
+Iteration 60/100, ave batch time 6.28 ms
+Images processed per second= 5094
+Iteration 70/100, ave batch time 6.26 ms
+Images processed per second= 5110
+Iteration 80/100, ave batch time 6.25 ms
+Images processed per second= 5118
+Iteration 90/100, ave batch time 6.25 ms
+Images processed per second= 5115
+Iteration 100/100, ave batch time 6.40 ms
+Images processed per second= 5002
+Input shape: torch.Size([32, 3, 224, 224])
+Output features size: torch.Size([32, 1000])
+Average batch time: 6.40 ms
+
+ + With the baseline ready, we can proceed to the section working discussing dynamic shapes! +
++ Enabling “Dynamic Shaped” tensors to be used is essentially enabling the ability to defer defining the shape of tensors until runetime. Torch TensorRT simply leverages TensorRT’s Dynamic shape support. You can read more about TensorRT’s implementation in the + + TensorRT Documentation + + . +
+
+ To make use of dynamic shapes, you need to provide three shapes: *
+
+
+ min_shape
+
+
+ : The minimum size of the tensor considered for optimizations. *
+
+
+ opt_shape
+
+
+ : The optimizations will be done with an effort to maximize performance for this shape. *
+
+
+ min_shape
+
+
+ : The maximum size of the tensor considered for optimizations.
+
+ Generally, users can expect best performance within the specified ranges. Performance for other shapes may be be lower for other shapes (depending on the model ops and GPU used) +
++ In the following example, we will showcase varing batch size, which is the zeroth dimension of our input tensors. As Convolution operations require that the channel dimension be a build-time constant, we won’t be changing sizes of other channels in this example, but for models which contain ops conducive to changes in other channels, this functionality can be freely used. +
+[11]:
+
+
+# The compiled module will have precision as specified by "op_precision".
+# Here, it will have FP32 precision.
+trt_model_with_ds = torch_tensorrt.compile(model, inputs = [torch_tensorrt.Input(
+ min_shape=(16, 3, 224, 224),
+ opt_shape=(32, 3, 224, 224),
+ max_shape=(64, 3, 224, 224),
+ dtype=torch.float32)],
+ enabled_precisions = torch.float32, # Run with FP32
+ workspace_size = 1 << 33
+)
+
+
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+
+ [12]:
+
+
+benchmark(trt_model_with_ds, input_shape=(16, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 3.88 ms
+Images processed per second= 4122
+Iteration 20/100, ave batch time 3.89 ms
+Images processed per second= 4116
+Iteration 30/100, ave batch time 3.88 ms
+Images processed per second= 4123
+Iteration 40/100, ave batch time 3.86 ms
+Images processed per second= 4142
+Iteration 50/100, ave batch time 3.85 ms
+Images processed per second= 4156
+Iteration 60/100, ave batch time 3.84 ms
+Images processed per second= 4166
+Iteration 70/100, ave batch time 3.84 ms
+Images processed per second= 4170
+Iteration 80/100, ave batch time 3.83 ms
+Images processed per second= 4172
+Iteration 90/100, ave batch time 3.83 ms
+Images processed per second= 4176
+Iteration 100/100, ave batch time 3.83 ms
+Images processed per second= 4178
+Input shape: torch.Size([16, 3, 224, 224])
+Output features size: torch.Size([16, 1000])
+Average batch time: 3.83 ms
+
+ [13]:
+
+
+benchmark(trt_model_with_ds, input_shape=(32, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 6.71 ms
+Images processed per second= 4767
+Iteration 20/100, ave batch time 6.48 ms
+Images processed per second= 4935
+Iteration 30/100, ave batch time 6.39 ms
+Images processed per second= 5005
+Iteration 40/100, ave batch time 6.38 ms
+Images processed per second= 5014
+Iteration 50/100, ave batch time 6.38 ms
+Images processed per second= 5016
+Iteration 60/100, ave batch time 6.37 ms
+Images processed per second= 5020
+Iteration 70/100, ave batch time 6.37 ms
+Images processed per second= 5024
+Iteration 80/100, ave batch time 6.37 ms
+Images processed per second= 5027
+Iteration 90/100, ave batch time 6.37 ms
+Images processed per second= 5026
+Iteration 100/100, ave batch time 6.38 ms
+Images processed per second= 5018
+Input shape: torch.Size([32, 3, 224, 224])
+Output features size: torch.Size([32, 1000])
+Average batch time: 6.38 ms
+
+ [14]:
+
+
+benchmark(trt_model_with_ds, input_shape=(64, 3, 224, 224), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, ave batch time 12.31 ms
+Images processed per second= 5197
+Iteration 20/100, ave batch time 12.42 ms
+Images processed per second= 5153
+Iteration 30/100, ave batch time 12.85 ms
+Images processed per second= 4980
+Iteration 40/100, ave batch time 12.71 ms
+Images processed per second= 5033
+Iteration 50/100, ave batch time 12.67 ms
+Images processed per second= 5052
+Iteration 60/100, ave batch time 12.63 ms
+Images processed per second= 5067
+Iteration 70/100, ave batch time 12.58 ms
+Images processed per second= 5088
+Iteration 80/100, ave batch time 12.56 ms
+Images processed per second= 5096
+Iteration 90/100, ave batch time 12.55 ms
+Images processed per second= 5100
+Iteration 100/100, ave batch time 12.57 ms
+Images processed per second= 5091
+Input shape: torch.Size([64, 3, 224, 224])
+Output features size: torch.Size([64, 1000])
+Average batch time: 12.57 ms
+
+ + Check out the + + TensorRT Getting started page + + for more tutorials, or visit the Torch-TensorRT + + documentation + + for more information! +
+[1]:
+
+
+# Copyright 2019 NVIDIA Corporation. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+
+
+ In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the +best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch’s JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new +world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference. +
++ When deploying on NVIDIA GPUs TensorRT, NVIDIA’s Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA’s Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that +perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device. +
++ Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch. +
++ This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a simple LeNet network. +
++ + Requirements + +
++ ## 1. Requirements +
+
+ Follow the steps in
+
+
+ notebooks/README
+
+
+ to prepare a Docker container, within which you can run this notebook.
+
[1]:
+
+
+!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org
+!nvidia-smi
+
+
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Collecting ipywidgets
+ Downloading ipywidgets-7.6.5-py2.py3-none-any.whl (121 kB)
+ |████████████████████████████████| 121 kB 12.7 MB/s eta 0:00:01
+Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)
+Collecting jupyterlab-widgets>=1.0.0
+ Downloading jupyterlab_widgets-1.0.2-py3-none-any.whl (243 kB)
+ |████████████████████████████████| 243 kB 115.0 MB/s eta 0:00:01
+Requirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)
+Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)
+Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.7.0)
+Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (7.31.0)
+Collecting widgetsnbextension~=3.5.0
+ Downloading widgetsnbextension-3.5.2-py2.py3-none-any.whl (1.6 MB)
+ |████████████████████████████████| 1.6 MB 122.5 MB/s eta 0:00:01
+Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)
+Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)
+Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)
+Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)
+Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)
+Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)
+Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)
+Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)
+Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)
+Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.24)
+Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)
+Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.0)
+Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.1)
+Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)
+Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)
+Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)
+Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)
+Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)
+Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)
+Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)
+Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)
+Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)
+Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)
+Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)
+Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)
+Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)
+Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.5.0->ipywidgets) (6.4.1)
+Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.12.1)
+Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.13.0)
+Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.3)
+Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3.0)
+Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (6.4.0)
+Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.8.0)
+Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.2.0)
+Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.15.0)
+Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.21)
+Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.0.1)
+Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.0)
+Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.7.1)
+Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.1.2)
+Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.10)
+Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (4.1.0)
+Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.5.0)
+Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.8.4)
+Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.1)
+Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3)
+Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.6)
+Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets
+Successfully installed ipywidgets-7.6.5 jupyterlab-widgets-1.0.2 widgetsnbextension-3.5.2
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+Thu Feb 10 22:01:27 2022
++-----------------------------------------------------------------------------+
+| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |
+|-------------------------------+----------------------+----------------------+
+| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
+| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
+| | | MIG M. |
+|===============================+======================+======================|
+| 0 NVIDIA GeForce ... On | 00000000:09:00.0 Off | N/A |
+| 0% 42C P8 20W / 320W | 0MiB / 10240MiB | 0% Default |
+| | | N/A |
++-------------------------------+----------------------+----------------------+
+
++-----------------------------------------------------------------------------+
+| Processes: |
+| GPU GI CI PID Type Process name GPU Memory |
+| ID ID Usage |
+|=============================================================================|
+| No running processes found |
++-----------------------------------------------------------------------------+
+
+ + ## 2. Creating TorchScript modules +
++ Here we create two submodules for a feature extractor and a classifier and stitch them together in a single LeNet module. In this case this is overkill but modules give us granular control over our program including where we decide to optimize and where we don’t. It is also the unit that the TorchScript compiler operates on. So you can decide to only convert/optimize the feature extractor and leave the classifier in standard PyTorch or you can convert the whole thing. When compiling your module +to TorchScript, there are two paths: Tracing and Scripting. +
+[2]:
+
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+class LeNetFeatExtractor(nn.Module):
+ def __init__(self):
+ super(LeNetFeatExtractor, self).__init__()
+ self.conv1 = nn.Conv2d(1, 128, 3)
+ self.conv2 = nn.Conv2d(128, 16, 3)
+
+ def forward(self, x):
+ x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
+ x = F.max_pool2d(F.relu(self.conv2(x)), 2)
+ return x
+
+class LeNetClassifier(nn.Module):
+ def __init__(self):
+ super(LeNetClassifier, self).__init__()
+ self.fc1 = nn.Linear(16 * 6 * 6, 120)
+ self.fc2 = nn.Linear(120, 84)
+ self.fc3 = nn.Linear(84, 10)
+
+ def forward(self, x):
+ x = torch.flatten(x,1)
+ x = F.relu(self.fc1(x))
+ x = F.relu(self.fc2(x))
+ x = self.fc3(x)
+ return x
+
+class LeNet(nn.Module):
+ def __init__(self):
+ super(LeNet, self).__init__()
+ self.feat = LeNetFeatExtractor()
+ self.classifer = LeNetClassifier()
+
+ def forward(self, x):
+ x = self.feat(x)
+ x = self.classifer(x)
+ return x
+
+
+ + Let us define a helper function to benchmark a model. +
+[3]:
+
+
+import time
+import numpy as np
+
+import torch.backends.cudnn as cudnn
+cudnn.benchmark = True
+
+def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=1000):
+ input_data = torch.randn(input_shape)
+ input_data = input_data.to("cuda")
+ if dtype=='fp16':
+ input_data = input_data.half()
+
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(nwarmup):
+ features = model(input_data)
+ torch.cuda.synchronize()
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(1, nruns+1):
+ start_time = time.time()
+ features = model(input_data)
+ torch.cuda.synchronize()
+ end_time = time.time()
+ timings.append(end_time - start_time)
+ if i%100==0:
+ print('Iteration %d/%d, ave batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))
+
+ print("Input shape:", input_data.size())
+ print("Output features size:", features.size())
+
+ print('Average batch time: %.2f ms'%(np.mean(timings)*1000))
+
+ [4]:
+
+
+model = LeNet()
+model.to("cuda").eval()
+
+ [4]:
+
+
+LeNet(
+ (feat): LeNetFeatExtractor(
+ (conv1): Conv2d(1, 128, kernel_size=(3, 3), stride=(1, 1))
+ (conv2): Conv2d(128, 16, kernel_size=(3, 3), stride=(1, 1))
+ )
+ (classifer): LeNetClassifier(
+ (fc1): Linear(in_features=576, out_features=120, bias=True)
+ (fc2): Linear(in_features=120, out_features=84, bias=True)
+ (fc3): Linear(in_features=84, out_features=10, bias=True)
+ )
+)
+
+ [5]:
+
+
+benchmark(model)
+
+
+Warm up ...
+Start timing ...
+Iteration 100/1000, ave batch time 5.56 ms
+Iteration 200/1000, ave batch time 5.56 ms
+Iteration 300/1000, ave batch time 5.56 ms
+Iteration 400/1000, ave batch time 5.56 ms
+Iteration 500/1000, ave batch time 5.56 ms
+Iteration 600/1000, ave batch time 5.56 ms
+Iteration 700/1000, ave batch time 5.56 ms
+Iteration 800/1000, ave batch time 5.56 ms
+Iteration 900/1000, ave batch time 5.56 ms
+Iteration 1000/1000, ave batch time 5.56 ms
+Input shape: torch.Size([1024, 1, 32, 32])
+Output features size: torch.Size([1024, 10])
+Average batch time: 5.56 ms
+
+ + When compiling your module to TorchScript, there are two paths: Tracing and Scripting. +
++ Tracing follows the path of execution when the module is called and records what happens. This recording is what the TorchScript IR will describe. To trace an instance of our LeNet module, we can call torch.jit.trace with an example input. +
+[6]:
+
+
+traced_model = torch.jit.trace(model, torch.empty([1,1,32,32]).to("cuda"))
+traced_model
+
+ [6]:
+
+
+LeNet(
+ original_name=LeNet
+ (feat): LeNetFeatExtractor(
+ original_name=LeNetFeatExtractor
+ (conv1): Conv2d(original_name=Conv2d)
+ (conv2): Conv2d(original_name=Conv2d)
+ )
+ (classifer): LeNetClassifier(
+ original_name=LeNetClassifier
+ (fc1): Linear(original_name=Linear)
+ (fc2): Linear(original_name=Linear)
+ (fc3): Linear(original_name=Linear)
+ )
+)
+
+ [7]:
+
+
+benchmark(traced_model)
+
+
+Warm up ...
+Start timing ...
+Iteration 100/1000, ave batch time 5.56 ms
+Iteration 200/1000, ave batch time 5.56 ms
+Iteration 300/1000, ave batch time 5.56 ms
+Iteration 400/1000, ave batch time 5.56 ms
+Iteration 500/1000, ave batch time 5.56 ms
+Iteration 600/1000, ave batch time 5.56 ms
+Iteration 700/1000, ave batch time 5.56 ms
+Iteration 800/1000, ave batch time 5.56 ms
+Iteration 900/1000, ave batch time 5.56 ms
+Iteration 1000/1000, ave batch time 5.56 ms
+Input shape: torch.Size([1024, 1, 32, 32])
+Output features size: torch.Size([1024, 10])
+Average batch time: 5.56 ms
+
+ + Scripting actually inspects your code with a compiler and generates an equivalent TorchScript program. The difference is that since tracing simply follows the execution of your module, it cannot pick up control flow for instance, it will only follow the code path that a particular input triggers. By working from the Python code, the compiler can include these components. We can run the script compiler on our LeNet module by calling torch.jit.script. +
+[8]:
+
+
+model = LeNet().to("cuda").eval()
+script_model = torch.jit.script(model)
+
+
+ [9]:
+
+
+script_model
+
+ [9]:
+
+
+RecursiveScriptModule(
+ original_name=LeNet
+ (feat): RecursiveScriptModule(
+ original_name=LeNetFeatExtractor
+ (conv1): RecursiveScriptModule(original_name=Conv2d)
+ (conv2): RecursiveScriptModule(original_name=Conv2d)
+ )
+ (classifer): RecursiveScriptModule(
+ original_name=LeNetClassifier
+ (fc1): RecursiveScriptModule(original_name=Linear)
+ (fc2): RecursiveScriptModule(original_name=Linear)
+ (fc3): RecursiveScriptModule(original_name=Linear)
+ )
+)
+
+ [10]:
+
+
+benchmark(script_model)
+
+
+Warm up ...
+Start timing ...
+Iteration 100/1000, ave batch time 5.56 ms
+Iteration 200/1000, ave batch time 5.56 ms
+Iteration 300/1000, ave batch time 5.56 ms
+Iteration 400/1000, ave batch time 5.56 ms
+Iteration 500/1000, ave batch time 5.56 ms
+Iteration 600/1000, ave batch time 5.56 ms
+Iteration 700/1000, ave batch time 5.56 ms
+Iteration 800/1000, ave batch time 5.56 ms
+Iteration 900/1000, ave batch time 5.56 ms
+Iteration 1000/1000, ave batch time 5.56 ms
+Input shape: torch.Size([1024, 1, 32, 32])
+Output features size: torch.Size([1024, 10])
+Average batch time: 5.56 ms
+
+ + ## 3. Compiling with Torch-TensorRT +
++ First, we compile the TorchScript traced model with Torch-TensorRT. Notice the performance impact. +
+[13]:
+
+
+import torch_tensorrt
+
+# We use a batch-size of 1024, and half precision
+trt_ts_module = torch_tensorrt.compile(traced_model, inputs=[torch_tensorrt.Input(
+ min_shape=[1024, 1, 32, 32],
+ opt_shape=[1024, 1, 33, 33],
+ max_shape=[1024, 1, 34, 34],
+ dtype=torch.half
+ )],
+ enabled_precisions = {torch.half})
+
+input_data = torch.randn((1024, 1, 32, 32))
+input_data = input_data.half().to("cuda")
+
+input_data = input_data.half()
+result = trt_ts_module(input_data)
+torch.jit.save(trt_ts_module, "trt_ts_module.ts")
+
+
+WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float
+The compiler is going to use the user setting Float16
+This conflict may cause an error at runtime due to partial compilation being enabled and therefore
+compatibility with PyTorch's data type convention is required.
+If you do indeed see errors at runtime either:
+- Remove the dtype spec for x.1
+- Disable partial compilation by setting require_full_compilation to True
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT TorchScript Conversion Context] - Max value of this profile is not valid
+
+ [14]:
+
+
+benchmark(trt_ts_module, input_shape=(1024, 1, 32, 32), dtype="fp16")
+
+
+Warm up ...
+Start timing ...
+Iteration 100/1000, ave batch time 1.41 ms
+Iteration 200/1000, ave batch time 1.40 ms
+Iteration 300/1000, ave batch time 1.40 ms
+Iteration 400/1000, ave batch time 1.39 ms
+Iteration 500/1000, ave batch time 1.40 ms
+Iteration 600/1000, ave batch time 1.40 ms
+Iteration 700/1000, ave batch time 1.40 ms
+Iteration 800/1000, ave batch time 1.40 ms
+Iteration 900/1000, ave batch time 1.40 ms
+Iteration 1000/1000, ave batch time 1.40 ms
+Input shape: torch.Size([1024, 1, 32, 32])
+Output features size: torch.Size([1024, 10])
+Average batch time: 1.40 ms
+
+ + Next, we compile the TorchScript script model with Torch-TensorRT. Notice the performance impact. +
+[16]:
+
+
+import torch_tensorrt
+
+trt_script_module = torch_tensorrt.compile(script_model, inputs = [torch_tensorrt.Input(
+ min_shape=[1024, 1, 32, 32],
+ opt_shape=[1024, 1, 33, 33],
+ max_shape=[1024, 1, 34, 34],
+ dtype=torch.half
+ )],
+ enabled_precisions={torch.half})
+
+input_data = torch.randn((1024, 1, 32, 32))
+input_data = input_data.half().to("cuda")
+
+input_data = input_data.half()
+result = trt_script_module(input_data)
+torch.jit.save(trt_script_module, "trt_script_module.ts")
+
+
+WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float
+The compiler is going to use the user setting Float16
+This conflict may cause an error at runtime due to partial compilation being enabled and therefore
+compatibility with PyTorch's data type convention is required.
+If you do indeed see errors at runtime either:
+- Remove the dtype spec for x.1
+- Disable partial compilation by setting require_full_compilation to True
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT TorchScript Conversion Context] - Max value of this profile is not valid
+
+ [17]:
+
+
+benchmark(trt_script_module, input_shape=(1024, 1, 32, 32), dtype="fp16")
+
+
+Warm up ...
+Start timing ...
+Iteration 100/1000, ave batch time 1.43 ms
+Iteration 200/1000, ave batch time 1.41 ms
+Iteration 300/1000, ave batch time 1.40 ms
+Iteration 400/1000, ave batch time 1.42 ms
+Iteration 500/1000, ave batch time 1.42 ms
+Iteration 600/1000, ave batch time 1.41 ms
+Iteration 700/1000, ave batch time 1.41 ms
+Iteration 800/1000, ave batch time 1.40 ms
+Iteration 900/1000, ave batch time 1.40 ms
+Iteration 1000/1000, ave batch time 1.40 ms
+Input shape: torch.Size([1024, 1, 32, 32])
+Output features size: torch.Size([1024, 10])
+Average batch time: 1.40 ms
+
+ + In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT and test the performance impact of the optimization. +
++ Now it’s time to try Torch-TensorRT on your own model. Fill out issues at + + https://github.com/NVIDIA/Torch-TensorRT + + . Your involvement will help future development of Torch-TensorRT. +
+\n",
+ "\n",
+ "# Torch-TensorRT Getting Started - LeNet"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a simple LeNet network. \n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [Creating TorchScript modules](#2)\n",
+ "1. [Compiling with Torch-TensorRT](#3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "Follow the steps in `notebooks/README` to prepare a Docker container, within which you can run this notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting ipywidgets\n",
+ " Downloading ipywidgets-7.6.5-py2.py3-none-any.whl (121 kB)\n",
+ "\u001b[K |████████████████████████████████| 121 kB 12.7 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)\n",
+ "Collecting jupyterlab-widgets>=1.0.0\n",
+ " Downloading jupyterlab_widgets-1.0.2-py3-none-any.whl (243 kB)\n",
+ "\u001b[K |████████████████████████████████| 243 kB 115.0 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)\n",
+ "Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.7.0)\n",
+ "Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (7.31.0)\n",
+ "Collecting widgetsnbextension~=3.5.0\n",
+ " Downloading widgetsnbextension-3.5.2-py2.py3-none-any.whl (1.6 MB)\n",
+ "\u001b[K |████████████████████████████████| 1.6 MB 122.5 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)\n",
+ "Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)\n",
+ "Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)\n",
+ "Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)\n",
+ "Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)\n",
+ "Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)\n",
+ "Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)\n",
+ "Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)\n",
+ "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.24)\n",
+ "Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.0)\n",
+ "Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.1)\n",
+ "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)\n",
+ "Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)\n",
+ "Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)\n",
+ "Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)\n",
+ "Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)\n",
+ "Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)\n",
+ "Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)\n",
+ "Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)\n",
+ "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)\n",
+ "Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)\n",
+ "Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)\n",
+ "Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.5.0->ipywidgets) (6.4.1)\n",
+ "Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.12.1)\n",
+ "Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.13.0)\n",
+ "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.3)\n",
+ "Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3.0)\n",
+ "Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (6.4.0)\n",
+ "Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.8.0)\n",
+ "Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.2.0)\n",
+ "Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.15.0)\n",
+ "Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.21)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.0.1)\n",
+ "Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.0)\n",
+ "Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.7.1)\n",
+ "Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.1.2)\n",
+ "Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.10)\n",
+ "Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (4.1.0)\n",
+ "Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.5.0)\n",
+ "Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.8.4)\n",
+ "Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.1)\n",
+ "Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.6)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets\n",
+ "Successfully installed ipywidgets-7.6.5 jupyterlab-widgets-1.0.2 widgetsnbextension-3.5.2\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
+ "Thu Feb 10 22:01:27 2022 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 NVIDIA GeForce ... On | 00000000:09:00.0 Off | N/A |\n",
+ "| 0% 42C P8 20W / 320W | 0MiB / 10240MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=============================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------+\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org\n",
+ "!nvidia-smi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. Creating TorchScript modules\n",
+ "\n",
+ "Here we create two submodules for a feature extractor and a classifier and stitch them together in a single LeNet module. In this case this is overkill but modules give us granular control over our program including where we decide to optimize and where we don't. It is also the unit that the TorchScript compiler operates on. So you can decide to only convert/optimize the feature extractor and leave the classifier in standard PyTorch or you can convert the whole thing. When compiling your module to TorchScript, there are two paths: Tracing and Scripting. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch \n",
+ "from torch import nn\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class LeNetFeatExtractor(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(LeNetFeatExtractor, self).__init__()\n",
+ " self.conv1 = nn.Conv2d(1, 128, 3)\n",
+ " self.conv2 = nn.Conv2d(128, 16, 3)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
+ " x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
+ " return x\n",
+ "\n",
+ "class LeNetClassifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(LeNetClassifier, self).__init__()\n",
+ " self.fc1 = nn.Linear(16 * 6 * 6, 120)\n",
+ " self.fc2 = nn.Linear(120, 84)\n",
+ " self.fc3 = nn.Linear(84, 10)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = torch.flatten(x,1)\n",
+ " x = F.relu(self.fc1(x))\n",
+ " x = F.relu(self.fc2(x))\n",
+ " x = self.fc3(x)\n",
+ " return x\n",
+ "\n",
+ "class LeNet(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(LeNet, self).__init__()\n",
+ " self.feat = LeNetFeatExtractor()\n",
+ " self.classifer = LeNetClassifier()\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = self.feat(x)\n",
+ " x = self.classifer(x)\n",
+ " return x\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let us define a helper function to benchmark a model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "import numpy as np\n",
+ "\n",
+ "import torch.backends.cudnn as cudnn\n",
+ "cudnn.benchmark = True\n",
+ "\n",
+ "def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=1000):\n",
+ " input_data = torch.randn(input_shape)\n",
+ " input_data = input_data.to(\"cuda\")\n",
+ " if dtype=='fp16':\n",
+ " input_data = input_data.half()\n",
+ " \n",
+ " print(\"Warm up ...\")\n",
+ " with torch.no_grad():\n",
+ " for _ in range(nwarmup):\n",
+ " features = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " print(\"Start timing ...\")\n",
+ " timings = []\n",
+ " with torch.no_grad():\n",
+ " for i in range(1, nruns+1):\n",
+ " start_time = time.time()\n",
+ " features = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " end_time = time.time()\n",
+ " timings.append(end_time - start_time)\n",
+ " if i%100==0:\n",
+ " print('Iteration %d/%d, ave batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))\n",
+ "\n",
+ " print(\"Input shape:\", input_data.size())\n",
+ " print(\"Output features size:\", features.size())\n",
+ " \n",
+ " print('Average batch time: %.2f ms'%(np.mean(timings)*1000))\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### PyTorch model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "LeNet(\n",
+ " (feat): LeNetFeatExtractor(\n",
+ " (conv1): Conv2d(1, 128, kernel_size=(3, 3), stride=(1, 1))\n",
+ " (conv2): Conv2d(128, 16, kernel_size=(3, 3), stride=(1, 1))\n",
+ " )\n",
+ " (classifer): LeNetClassifier(\n",
+ " (fc1): Linear(in_features=576, out_features=120, bias=True)\n",
+ " (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
+ " (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model = LeNet()\n",
+ "model.to(\"cuda\").eval()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 5.56 ms\n",
+ "Iteration 200/1000, ave batch time 5.56 ms\n",
+ "Iteration 300/1000, ave batch time 5.56 ms\n",
+ "Iteration 400/1000, ave batch time 5.56 ms\n",
+ "Iteration 500/1000, ave batch time 5.56 ms\n",
+ "Iteration 600/1000, ave batch time 5.56 ms\n",
+ "Iteration 700/1000, ave batch time 5.56 ms\n",
+ "Iteration 800/1000, ave batch time 5.56 ms\n",
+ "Iteration 900/1000, ave batch time 5.56 ms\n",
+ "Iteration 1000/1000, ave batch time 5.56 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 5.56 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "When compiling your module to TorchScript, there are two paths: Tracing and Scripting. \n",
+ " \n",
+ "### Tracing\n",
+ "\n",
+ "Tracing follows the path of execution when the module is called and records what happens. This recording is what the TorchScript IR will describe. To trace an instance of our LeNet module, we can call torch.jit.trace with an example input. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "LeNet(\n",
+ " original_name=LeNet\n",
+ " (feat): LeNetFeatExtractor(\n",
+ " original_name=LeNetFeatExtractor\n",
+ " (conv1): Conv2d(original_name=Conv2d)\n",
+ " (conv2): Conv2d(original_name=Conv2d)\n",
+ " )\n",
+ " (classifer): LeNetClassifier(\n",
+ " original_name=LeNetClassifier\n",
+ " (fc1): Linear(original_name=Linear)\n",
+ " (fc2): Linear(original_name=Linear)\n",
+ " (fc3): Linear(original_name=Linear)\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "traced_model = torch.jit.trace(model, torch.empty([1,1,32,32]).to(\"cuda\"))\n",
+ "traced_model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 5.56 ms\n",
+ "Iteration 200/1000, ave batch time 5.56 ms\n",
+ "Iteration 300/1000, ave batch time 5.56 ms\n",
+ "Iteration 400/1000, ave batch time 5.56 ms\n",
+ "Iteration 500/1000, ave batch time 5.56 ms\n",
+ "Iteration 600/1000, ave batch time 5.56 ms\n",
+ "Iteration 700/1000, ave batch time 5.56 ms\n",
+ "Iteration 800/1000, ave batch time 5.56 ms\n",
+ "Iteration 900/1000, ave batch time 5.56 ms\n",
+ "Iteration 1000/1000, ave batch time 5.56 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 5.56 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(traced_model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Scripting\n",
+ "\n",
+ "Scripting actually inspects your code with a compiler and generates an equivalent TorchScript program. The difference is that since tracing simply follows the execution of your module, it cannot pick up control flow for instance, it will only follow the code path that a particular input triggers. By working from the Python code, the compiler can include these components. We can run the script compiler on our LeNet module by calling torch.jit.script.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = LeNet().to(\"cuda\").eval()\n",
+ "script_model = torch.jit.script(model)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "RecursiveScriptModule(\n",
+ " original_name=LeNet\n",
+ " (feat): RecursiveScriptModule(\n",
+ " original_name=LeNetFeatExtractor\n",
+ " (conv1): RecursiveScriptModule(original_name=Conv2d)\n",
+ " (conv2): RecursiveScriptModule(original_name=Conv2d)\n",
+ " )\n",
+ " (classifer): RecursiveScriptModule(\n",
+ " original_name=LeNetClassifier\n",
+ " (fc1): RecursiveScriptModule(original_name=Linear)\n",
+ " (fc2): RecursiveScriptModule(original_name=Linear)\n",
+ " (fc3): RecursiveScriptModule(original_name=Linear)\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "script_model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 5.56 ms\n",
+ "Iteration 200/1000, ave batch time 5.56 ms\n",
+ "Iteration 300/1000, ave batch time 5.56 ms\n",
+ "Iteration 400/1000, ave batch time 5.56 ms\n",
+ "Iteration 500/1000, ave batch time 5.56 ms\n",
+ "Iteration 600/1000, ave batch time 5.56 ms\n",
+ "Iteration 700/1000, ave batch time 5.56 ms\n",
+ "Iteration 800/1000, ave batch time 5.56 ms\n",
+ "Iteration 900/1000, ave batch time 5.56 ms\n",
+ "Iteration 1000/1000, ave batch time 5.56 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 5.56 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(script_model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Compiling with Torch-TensorRT"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### TorchScript traced model\n",
+ "\n",
+ "First, we compile the TorchScript traced model with Torch-TensorRT. Notice the performance impact."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float\n",
+ "The compiler is going to use the user setting Float16\n",
+ "This conflict may cause an error at runtime due to partial compilation being enabled and therefore\n",
+ "compatibility with PyTorch's data type convention is required.\n",
+ "If you do indeed see errors at runtime either:\n",
+ "- Remove the dtype spec for x.1\n",
+ "- Disable partial compilation by setting require_full_compilation to True\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT TorchScript Conversion Context] - Max value of this profile is not valid\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch_tensorrt\n",
+ "\n",
+ "# We use a batch-size of 1024, and half precision\n",
+ "trt_ts_module = torch_tensorrt.compile(traced_model, inputs=[torch_tensorrt.Input(\n",
+ " min_shape=[1024, 1, 32, 32],\n",
+ " opt_shape=[1024, 1, 33, 33],\n",
+ " max_shape=[1024, 1, 34, 34],\n",
+ " dtype=torch.half\n",
+ " )], \n",
+ " enabled_precisions = {torch.half})\n",
+ "\n",
+ "input_data = torch.randn((1024, 1, 32, 32))\n",
+ "input_data = input_data.half().to(\"cuda\")\n",
+ "\n",
+ "input_data = input_data.half()\n",
+ "result = trt_ts_module(input_data)\n",
+ "torch.jit.save(trt_ts_module, \"trt_ts_module.ts\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 1.41 ms\n",
+ "Iteration 200/1000, ave batch time 1.40 ms\n",
+ "Iteration 300/1000, ave batch time 1.40 ms\n",
+ "Iteration 400/1000, ave batch time 1.39 ms\n",
+ "Iteration 500/1000, ave batch time 1.40 ms\n",
+ "Iteration 600/1000, ave batch time 1.40 ms\n",
+ "Iteration 700/1000, ave batch time 1.40 ms\n",
+ "Iteration 800/1000, ave batch time 1.40 ms\n",
+ "Iteration 900/1000, ave batch time 1.40 ms\n",
+ "Iteration 1000/1000, ave batch time 1.40 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 1.40 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(trt_ts_module, input_shape=(1024, 1, 32, 32), dtype=\"fp16\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### TorchScript script model\n",
+ "\n",
+ "Next, we compile the TorchScript script model with Torch-TensorRT. Notice the performance impact."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float\n",
+ "The compiler is going to use the user setting Float16\n",
+ "This conflict may cause an error at runtime due to partial compilation being enabled and therefore\n",
+ "compatibility with PyTorch's data type convention is required.\n",
+ "If you do indeed see errors at runtime either:\n",
+ "- Remove the dtype spec for x.1\n",
+ "- Disable partial compilation by setting require_full_compilation to True\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT TorchScript Conversion Context] - Max value of this profile is not valid\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch_tensorrt\n",
+ "\n",
+ "trt_script_module = torch_tensorrt.compile(script_model, inputs = [torch_tensorrt.Input(\n",
+ " min_shape=[1024, 1, 32, 32],\n",
+ " opt_shape=[1024, 1, 33, 33],\n",
+ " max_shape=[1024, 1, 34, 34],\n",
+ " dtype=torch.half\n",
+ " )],\n",
+ " enabled_precisions={torch.half})\n",
+ "\n",
+ "input_data = torch.randn((1024, 1, 32, 32))\n",
+ "input_data = input_data.half().to(\"cuda\")\n",
+ "\n",
+ "input_data = input_data.half()\n",
+ "result = trt_script_module(input_data)\n",
+ "torch.jit.save(trt_script_module, \"trt_script_module.ts\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 1.43 ms\n",
+ "Iteration 200/1000, ave batch time 1.41 ms\n",
+ "Iteration 300/1000, ave batch time 1.40 ms\n",
+ "Iteration 400/1000, ave batch time 1.42 ms\n",
+ "Iteration 500/1000, ave batch time 1.42 ms\n",
+ "Iteration 600/1000, ave batch time 1.41 ms\n",
+ "Iteration 700/1000, ave batch time 1.41 ms\n",
+ "Iteration 800/1000, ave batch time 1.40 ms\n",
+ "Iteration 900/1000, ave batch time 1.40 ms\n",
+ "Iteration 1000/1000, ave batch time 1.40 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 1.40 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(trt_script_module, input_shape=(1024, 1, 32, 32), dtype=\"fp16\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Conclusion\n",
+ "\n",
+ "In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT and test the performance impact of the optimization.\n",
+ "\n",
+ "### What's next\n",
+ "Now it's time to try Torch-TensorRT on your own model. Fill out issues at https://github.com/NVIDIA/Torch-TensorRT. Your involvement will help future development of Torch-TensorRT.\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/v1.1.1/_notebooks/ssd-object-detection-demo.html b/docs/v1.1.1/_notebooks/ssd-object-detection-demo.html
new file mode 100644
index 0000000000..73b0bf41c1
--- /dev/null
+++ b/docs/v1.1.1/_notebooks/ssd-object-detection-demo.html
@@ -0,0 +1,2080 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ [1]:
+
+
+# Copyright 2020 NVIDIA Corporation. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+ 
+
+ In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the +best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch’s JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new +world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference. +
++ When deploying on NVIDIA GPUs TensorRT, NVIDIA’s Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA’s Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that +perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device. +
++ Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch. +
++ This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained SSD network, and running it to test the speedup obtained. +
++ + Requirements + +
++ + SSD Overview + +
++ + Conclusion + +
++ ## 1. Requirements +
+
+ Follow the steps in
+
+
+ notebooks/README
+
+
+ to prepare a Docker container, within which you can run this demo notebook.
+
+ In addition to that, run the following cell to obtain additional libraries specific to this demo. +
+[2]:
+
+
+!pip install scikit-image==0.19.1
+!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org
+
+
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Collecting scikit-image==0.19.1
+ Downloading scikit_image-0.19.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.8 MB)
+ |████████████████████████████████| 13.8 MB 8.8 MB/s eta 0:00:01
+Requirement already satisfied: networkx>=2.2 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (2.6.3)
+Collecting tifffile>=2019.7.26
+ Downloading tifffile-2022.3.16-py3-none-any.whl (179 kB)
+ |████████████████████████████████| 179 kB 110.1 MB/s eta 0:00:01
+Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (21.3)
+Requirement already satisfied: scipy>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (1.6.3)
+Requirement already satisfied: numpy>=1.17.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (1.22.2)
+Collecting imageio>=2.4.1
+ Downloading imageio-2.16.1-py3-none-any.whl (3.3 MB)
+ |████████████████████████████████| 3.3 MB 42.3 MB/s eta 0:00:01
+Requirement already satisfied: pillow!=7.1.0,!=7.1.1,!=8.3.0,>=6.1.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (9.0.0)
+Collecting PyWavelets>=1.1.1
+ Downloading PyWavelets-1.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.9 MB)
+ |████████████████████████████████| 6.9 MB 61.3 MB/s eta 0:00:01
+Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging>=20.0->scikit-image==0.19.1) (3.0.7)
+Installing collected packages: tifffile, PyWavelets, imageio, scikit-image
+Successfully installed PyWavelets-1.3.0 imageio-2.16.1 scikit-image-0.19.1 tifffile-2022.3.16
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com
+Collecting ipywidgets
+ Downloading ipywidgets-7.7.0-py2.py3-none-any.whl (123 kB)
+ |████████████████████████████████| 123 kB 12.1 MB/s eta 0:00:01
+Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.9.0)
+Collecting jupyterlab-widgets>=1.0.0
+ Downloading jupyterlab_widgets-1.1.0-py3-none-any.whl (245 kB)
+ |████████████████████████████████| 245 kB 60.6 MB/s eta 0:00:01
+Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)
+Requirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)
+Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (8.0.1)
+Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)
+Collecting widgetsnbextension~=3.6.0
+ Downloading widgetsnbextension-3.6.0-py2.py3-none-any.whl (1.6 MB)
+ |████████████████████████████████| 1.6 MB 35.2 MB/s eta 0:00:01
+Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)
+Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)
+Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)
+Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)
+Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)
+Requirement already satisfied: stack-data in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.1.4)
+Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.26)
+Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)
+Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.2)
+Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)
+Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.1)
+Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)
+Requirement already satisfied: black in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (22.1.0)
+Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)
+Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)
+Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)
+Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)
+Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)
+Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)
+Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)
+Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)
+Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)
+Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)
+Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)
+Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)
+Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)
+Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)
+Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)
+Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.6.0->ipywidgets) (6.4.1)
+Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.13.1)
+Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.8.0)
+Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.13.1)
+Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (3.0.3)
+Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (6.4.2)
+Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.3.0)
+Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.2.0)
+Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.15.0)
+Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.21)
+Requirement already satisfied: pathspec>=0.9.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (0.9.0)
+Requirement already satisfied: tomli>=1.1.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (2.0.1)
+Requirement already satisfied: mypy-extensions>=0.4.3 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (0.4.3)
+Requirement already satisfied: click>=8.0.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (8.0.3)
+Requirement already satisfied: platformdirs>=2 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (2.4.1)
+Requirement already satisfied: typing-extensions>=3.10.0.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (4.0.1)
+Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.0.1)
+Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.7.1)
+Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.8.4)
+Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.11)
+Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.0)
+Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.1.2)
+Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (4.1.0)
+Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.5.0)
+Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.1)
+Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.3)
+Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (3.0.7)
+Requirement already satisfied: executing in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.8.2)
+Requirement already satisfied: pure-eval in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.2.2)
+Requirement already satisfied: asttokens in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (2.0.5)
+Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets
+Successfully installed ipywidgets-7.7.0 jupyterlab-widgets-1.1.0 widgetsnbextension-3.6.0
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+
+ + ## 2. SSD +
+|
+ + _ + + |
+
+ + _ + + |
+
|---|---|
|
+
+ |
+
+
+ |
+
+ PyTorch has a model repository called the PyTorch Hub, which is a source for high quality implementations of common models. We can get our SSD model pretrained on + + COCO + + from there. +
++ This SSD300 model is based on the + + SSD: Single Shot MultiBox Detector + + paper, which describes SSD as “a method for detecting objects in images using a single deep neural network”. The input size is fixed to 300x300. +
++ The main difference between this model and the one described in the paper is in the backbone. Specifically, the VGG model is obsolete and is replaced by the ResNet-50 model. +
++ From the + + Speed/accuracy trade-offs for modern convolutional object detectors + + paper, the following enhancements were made to the backbone: * The conv5_x, avgpool, fc and softmax layers were removed from the original classification model. * All strides in conv4_x are set to 1x1. +
++ The backbone is followed by 5 additional convolutional layers. In addition to the convolutional layers, we attached 6 detection heads: * The first detection head is attached to the last conv4_x layer. * The other five detection heads are attached to the corresponding 5 additional layers. +
++ Detector heads are similar to the ones referenced in the paper, however, they are enhanced by additional BatchNorm layers after each convolution. +
++ More information about this SSD model is available at Nvidia’s “DeepLearningExamples” Github + + here + + . +
+
+ 
+ [3]:
+
+
+import torch
+torch.hub._validate_not_a_forked_repo=lambda a,b,c: True
+
+ [4]:
+
+
+# List of available models in PyTorch Hub from Nvidia/DeepLearningExamples
+torch.hub.list('NVIDIA/DeepLearningExamples:torchhub')
+
+
+Downloading: "https://github.com/NVIDIA/DeepLearningExamples/archive/torchhub.zip" to /root/.cache/torch/hub/torchhub.zip
+/root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub/PyTorch/Classification/ConvNets/image_classification/models/efficientnet.py:17: UserWarning: pytorch_quantization module not found, quantization will not be available
+ warnings.warn(
+
+ [4]:
+
+
+['nvidia_convnets_processing_utils',
+ 'nvidia_efficientnet',
+ 'nvidia_efficientnet_b0',
+ 'nvidia_efficientnet_b4',
+ 'nvidia_efficientnet_widese_b0',
+ 'nvidia_efficientnet_widese_b4',
+ 'nvidia_resneXt',
+ 'nvidia_resnet50',
+ 'nvidia_resnext101_32x4d',
+ 'nvidia_se_resnext101_32x4d',
+ 'nvidia_ssd',
+ 'nvidia_ssd_processing_utils',
+ 'nvidia_tacotron2',
+ 'nvidia_tts_utils',
+ 'nvidia_waveglow']
+
+ [5]:
+
+
+# load SSD model pretrained on COCO from Torch Hub
+precision = 'fp32'
+ssd300 = torch.hub.load('NVIDIA/DeepLearningExamples:torchhub', 'nvidia_ssd', model_math=precision);
+
+
+Using cache found in /root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub
+Downloading: "https://download.pytorch.org/models/resnet50-0676ba61.pth" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth
+
+
+Downloading checkpoint from https://api.ngc.nvidia.com/v2/models/nvidia/ssd_pyt_ckpt_amp/versions/20.06.0/files/nvidia_ssdpyt_amp_200703.pt
+
+
+ Setting
+
+
+ precision="fp16"
+
+
+ will load a checkpoint trained with mixed precision into architecture enabling execution on Tensor Cores. Handling mixed precision data requires the Apex library.
+
+ We can now run inference on the model. This is demonstrated below using sample images from the COCO 2017 Validation set. +
+[6]:
+
+
+# Sample images from the COCO validation set
+uris = [
+ 'http://images.cocodataset.org/val2017/000000397133.jpg',
+ 'http://images.cocodataset.org/val2017/000000037777.jpg',
+ 'http://images.cocodataset.org/val2017/000000252219.jpg'
+]
+
+# For convenient and comprehensive formatting of input and output of the model, load a set of utility methods.
+utils = torch.hub.load('NVIDIA/DeepLearningExamples:torchhub', 'nvidia_ssd_processing_utils')
+
+# Format images to comply with the network input
+inputs = [utils.prepare_input(uri) for uri in uris]
+tensor = utils.prepare_tensor(inputs, False)
+
+# The model was trained on COCO dataset, which we need to access in order to
+# translate class IDs into object names.
+classes_to_labels = utils.get_coco_object_dictionary()
+
+
+Using cache found in /root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub
+
+
+Downloading COCO annotations.
+Downloading finished.
+
+ [7]:
+
+
+# Next, we run object detection
+model = ssd300.eval().to("cuda")
+detections_batch = model(tensor)
+
+# By default, raw output from SSD network per input image contains 8732 boxes with
+# localization and class probability distribution.
+# Let’s filter this output to only get reasonable detections (confidence>40%) in a more comprehensive format.
+results_per_input = utils.decode_results(detections_batch)
+best_results_per_input = [utils.pick_best(results, 0.40) for results in results_per_input]
+
+ [8]:
+
+
+from matplotlib import pyplot as plt
+import matplotlib.patches as patches
+
+# The utility plots the images and predicted bounding boxes (with confidence scores).
+def plot_results(best_results):
+ for image_idx in range(len(best_results)):
+ fig, ax = plt.subplots(1)
+ # Show original, denormalized image...
+ image = inputs[image_idx] / 2 + 0.5
+ ax.imshow(image)
+ # ...with detections
+ bboxes, classes, confidences = best_results[image_idx]
+ for idx in range(len(bboxes)):
+ left, bot, right, top = bboxes[idx]
+ x, y, w, h = [val * 300 for val in [left, bot, right - left, top - bot]]
+ rect = patches.Rectangle((x, y), w, h, linewidth=1, edgecolor='r', facecolor='none')
+ ax.add_patch(rect)
+ ax.text(x, y, "{} {:.0f}%".format(classes_to_labels[classes[idx] - 1], confidences[idx]*100), bbox=dict(facecolor='white', alpha=0.5))
+ plt.show()
+
+
+ [9]:
+
+
+# Visualize results without Torch-TensorRT
+plot_results(best_results_per_input)
+
+ 
+ 
+ 
+ [10]:
+
+
+import time
+import numpy as np
+
+import torch.backends.cudnn as cudnn
+cudnn.benchmark = True
+
+# Helper function to benchmark the model
+def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=1000):
+ input_data = torch.randn(input_shape)
+ input_data = input_data.to("cuda")
+ if dtype=='fp16':
+ input_data = input_data.half()
+
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(nwarmup):
+ features = model(input_data)
+ torch.cuda.synchronize()
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(1, nruns+1):
+ start_time = time.time()
+ pred_loc, pred_label = model(input_data)
+ torch.cuda.synchronize()
+ end_time = time.time()
+ timings.append(end_time - start_time)
+ if i%10==0:
+ print('Iteration %d/%d, avg batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))
+
+ print("Input shape:", input_data.size())
+ print("Output location prediction size:", pred_loc.size())
+ print("Output label prediction size:", pred_label.size())
+ print('Average batch time: %.2f ms'%(np.mean(timings)*1000))
+
+
+ + We check how well the model performs + + before + + we use Torch-TensorRT +
+[11]:
+
+
+# Model benchmark without Torch-TensorRT
+model = ssd300.eval().to("cuda")
+benchmark(model, input_shape=(128, 3, 300, 300), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, avg batch time 165.38 ms
+Iteration 20/100, avg batch time 165.99 ms
+Iteration 30/100, avg batch time 166.04 ms
+Iteration 40/100, avg batch time 166.32 ms
+Iteration 50/100, avg batch time 166.49 ms
+Iteration 60/100, avg batch time 166.74 ms
+Iteration 70/100, avg batch time 166.88 ms
+Iteration 80/100, avg batch time 167.05 ms
+Iteration 90/100, avg batch time 167.18 ms
+Iteration 100/100, avg batch time 167.31 ms
+Input shape: torch.Size([128, 3, 300, 300])
+Output location prediction size: torch.Size([128, 4, 8732])
+Output label prediction size: torch.Size([128, 81, 8732])
+Average batch time: 167.31 ms
+
+ + ## 3. Creating TorchScript modules +
++ To compile with Torch-TensorRT, the model must first be in + + TorchScript + + . TorchScript is a programming language included in PyTorch which removes the Python dependency normal PyTorch models have. This conversion is done via a JIT compiler which given a PyTorch Module will generate an equivalent TorchScript Module. There are two paths that can be used to generate TorchScript: + + Tracing + + and + + Scripting + + . - Tracing follows execution of PyTorch generating ops in TorchScript corresponding to +what it sees. - Scripting does an analysis of the Python code and generates TorchScript, this allows the resulting graph to include control flow which tracing cannot do. +
++ Tracing however due to its simplicity is more likely to compile successfully with Torch-TensorRT (though both systems are supported). +
+[12]:
+
+
+model = ssd300.eval().to("cuda")
+traced_model = torch.jit.trace(model, [torch.randn((1,3,300,300)).to("cuda")])
+
+ + If required, we can also save this model and use it independently of Python. +
+[13]:
+
+
+# This is just an example, and not required for the purposes of this demo
+torch.jit.save(traced_model, "ssd_300_traced.jit.pt")
+
+ [14]:
+
+
+# Obtain the average time taken by a batch of input with Torchscript compiled modules
+benchmark(traced_model, input_shape=(128, 3, 300, 300), nruns=100)
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, avg batch time 165.53 ms
+Iteration 20/100, avg batch time 166.19 ms
+Iteration 30/100, avg batch time 166.12 ms
+Iteration 40/100, avg batch time 166.16 ms
+Iteration 50/100, avg batch time 166.24 ms
+Iteration 60/100, avg batch time 166.33 ms
+Iteration 70/100, avg batch time 166.43 ms
+Iteration 80/100, avg batch time 166.44 ms
+Iteration 90/100, avg batch time 166.53 ms
+Iteration 100/100, avg batch time 166.59 ms
+Input shape: torch.Size([128, 3, 300, 300])
+Output location prediction size: torch.Size([128, 4, 8732])
+Output label prediction size: torch.Size([128, 81, 8732])
+Average batch time: 166.59 ms
+
+ + ## 4. Compiling with Torch-TensorRT TorchScript modules behave just like normal PyTorch modules and are intercompatible. From TorchScript we can now compile a TensorRT based module. This module will still be implemented in TorchScript but all the computation will be done in TensorRT. +
+[15]:
+
+
+import torch_tensorrt
+
+# The compiled module will have precision as specified by "op_precision".
+# Here, it will have FP16 precision.
+trt_model = torch_tensorrt.compile(traced_model,
+ inputs= [torch_tensorrt.Input((3, 3, 300, 300), dtype=torch.half)],
+ enabled_precisions= {torch.half}, # Run with FP16
+ workspace_size= 1 << 20
+)
+
+
+WARNING: [Torch-TensorRT] - For input x, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float
+The compiler is going to use the user setting Float16
+This conflict may cause an error at runtime due to partial compilation being enabled and therefore
+compatibility with PyTorch's data type convention is required.
+If you do indeed see errors at runtime either:
+- Remove the dtype spec for x
+- Disable partial compilation by setting require_full_compilation to True
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+
+ + ## 5. Running Inference +
++ Next, we run object detection +
+[16]:
+
+
+# using a Torch-TensorRT module is exactly the same as how we usually do inference in PyTorch i.e. model(inputs)
+detections_batch = trt_model(tensor.to(torch.half)) # convert the input to half precision
+
+# By default, raw output from SSD network per input image contains 8732 boxes with
+# localization and class probability distribution.
+# Let’s filter this output to only get reasonable detections (confidence>40%) in a more comprehensive format.
+results_per_input = utils.decode_results(detections_batch)
+best_results_per_input_trt = [utils.pick_best(results, 0.40) for results in results_per_input]
+
+ + Now, let’s visualize our predictions! +
+[17]:
+
+
+# Visualize results with Torch-TensorRT
+plot_results(best_results_per_input_trt)
+
+ 
+ 
+ 
+ + We get similar results as before! +
++ We can run the benchmark function again to see the speedup gained! Compare this result with the same batch-size of input in the case without Torch-TensorRT above. +
+[18]:
+
+
+batch_size = 128
+
+# Recompiling with batch_size we use for evaluating performance
+trt_model = torch_tensorrt.compile(traced_model,
+ inputs = [torch_tensorrt.Input((batch_size, 3, 300, 300), dtype=torch.half)],
+ enabled_precisions= {torch.half}, # Run with FP16
+ workspace_size= 1 << 20
+)
+
+benchmark(trt_model, input_shape=(batch_size, 3, 300, 300), dtype='fp16', nruns=100)
+
+
+WARNING: [Torch-TensorRT] - For input x, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float
+The compiler is going to use the user setting Float16
+This conflict may cause an error at runtime due to partial compilation being enabled and therefore
+compatibility with PyTorch's data type convention is required.
+If you do indeed see errors at runtime either:
+- Remove the dtype spec for x
+- Disable partial compilation by setting require_full_compilation to True
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+WARNING: [Torch-TensorRT] - There may be undefined behavior using dynamic shape and aten::size
+
+
+Warm up ...
+Start timing ...
+Iteration 10/100, avg batch time 45.88 ms
+Iteration 20/100, avg batch time 46.20 ms
+Iteration 30/100, avg batch time 46.10 ms
+Iteration 40/100, avg batch time 46.19 ms
+Iteration 50/100, avg batch time 46.15 ms
+Iteration 60/100, avg batch time 46.17 ms
+Iteration 70/100, avg batch time 46.19 ms
+Iteration 80/100, avg batch time 46.20 ms
+Iteration 90/100, avg batch time 46.22 ms
+Iteration 100/100, avg batch time 46.21 ms
+Input shape: torch.Size([128, 3, 300, 300])
+Output location prediction size: torch.Size([128, 4, 8732])
+Output label prediction size: torch.Size([128, 81, 8732])
+Average batch time: 46.21 ms
+
+ + In this notebook, we have walked through the complete process of compiling a TorchScript SSD300 model with Torch-TensorRT, and tested the performance impact of the optimization. We find that using the Torch-TensorRT compiled model, we gain significant speedup in inference without any noticeable drop in performance! +
++ For detailed information on model input and output, training recipies, inference and performance visit: + + github + + and/or + + NGC + +
++ + SSD: Single Shot MultiBox Detector + + paper +
++ + Speed/accuracy trade-offs for modern convolutional object detectors + + paper +
++ + SSD on NGC + +
+![](\"https://developer.download.nvidia.com/tesla/notebook_assets/nv_logo_torch_trt_ssd_notebook.png\"){kind=logo}
\n",
+ "\n",
+ "# Object Detection with Torch-TensorRT (SSD)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained SSD network, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Contents\n",
+ "1. [Requirements](#1)\n",
+ "2. [SSD Overview](#2)\n",
+ "3. [Creating TorchScript modules](#3)\n",
+ "4. [Compiling with Torch-TensorRT](#4)\n",
+ "5. [Running Inference](#5)\n",
+ "6. [Measuring Speedup](#6)\n",
+ "7. [Conclusion](#7)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "Follow the steps in `notebooks/README` to prepare a Docker container, within which you can run this demo notebook.\n",
+ "\n",
+ "In addition to that, run the following cell to obtain additional libraries specific to this demo."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting scikit-image==0.19.1\n",
+ " Downloading scikit_image-0.19.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.8 MB)\n",
+ "\u001b[K |████████████████████████████████| 13.8 MB 8.8 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: networkx>=2.2 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (2.6.3)\n",
+ "Collecting tifffile>=2019.7.26\n",
+ " Downloading tifffile-2022.3.16-py3-none-any.whl (179 kB)\n",
+ "\u001b[K |████████████████████████████████| 179 kB 110.1 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (21.3)\n",
+ "Requirement already satisfied: scipy>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (1.6.3)\n",
+ "Requirement already satisfied: numpy>=1.17.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (1.22.2)\n",
+ "Collecting imageio>=2.4.1\n",
+ " Downloading imageio-2.16.1-py3-none-any.whl (3.3 MB)\n",
+ "\u001b[K |████████████████████████████████| 3.3 MB 42.3 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: pillow!=7.1.0,!=7.1.1,!=8.3.0,>=6.1.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (9.0.0)\n",
+ "Collecting PyWavelets>=1.1.1\n",
+ " Downloading PyWavelets-1.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.9 MB)\n",
+ "\u001b[K |████████████████████████████████| 6.9 MB 61.3 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging>=20.0->scikit-image==0.19.1) (3.0.7)\n",
+ "Installing collected packages: tifffile, PyWavelets, imageio, scikit-image\n",
+ "Successfully installed PyWavelets-1.3.0 imageio-2.16.1 scikit-image-0.19.1 tifffile-2022.3.16\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting ipywidgets\n",
+ " Downloading ipywidgets-7.7.0-py2.py3-none-any.whl (123 kB)\n",
+ "\u001b[K |████████████████████████████████| 123 kB 12.1 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.9.0)\n",
+ "Collecting jupyterlab-widgets>=1.0.0\n",
+ " Downloading jupyterlab_widgets-1.1.0-py3-none-any.whl (245 kB)\n",
+ "\u001b[K |████████████████████████████████| 245 kB 60.6 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)\n",
+ "Requirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (8.0.1)\n",
+ "Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)\n",
+ "Collecting widgetsnbextension~=3.6.0\n",
+ " Downloading widgetsnbextension-3.6.0-py2.py3-none-any.whl (1.6 MB)\n",
+ "\u001b[K |████████████████████████████████| 1.6 MB 35.2 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)\n",
+ "Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)\n",
+ "Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)\n",
+ "Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)\n",
+ "Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)\n",
+ "Requirement already satisfied: stack-data in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.1.4)\n",
+ "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.26)\n",
+ "Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)\n",
+ "Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.2)\n",
+ "Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)\n",
+ "Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.1)\n",
+ "Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: black in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (22.1.0)\n",
+ "Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)\n",
+ "Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)\n",
+ "Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)\n",
+ "Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)\n",
+ "Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)\n",
+ "Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)\n",
+ "Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)\n",
+ "Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)\n",
+ "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)\n",
+ "Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)\n",
+ "Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)\n",
+ "Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)\n",
+ "Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.6.0->ipywidgets) (6.4.1)\n",
+ "Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.13.1)\n",
+ "Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.8.0)\n",
+ "Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.13.1)\n",
+ "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (3.0.3)\n",
+ "Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (6.4.2)\n",
+ "Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.3.0)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.2.0)\n",
+ "Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.15.0)\n",
+ "Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.21)\n",
+ "Requirement already satisfied: pathspec>=0.9.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (0.9.0)\n",
+ "Requirement already satisfied: tomli>=1.1.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (2.0.1)\n",
+ "Requirement already satisfied: mypy-extensions>=0.4.3 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (0.4.3)\n",
+ "Requirement already satisfied: click>=8.0.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (8.0.3)\n",
+ "Requirement already satisfied: platformdirs>=2 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (2.4.1)\n",
+ "Requirement already satisfied: typing-extensions>=3.10.0.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (4.0.1)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.0.1)\n",
+ "Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.7.1)\n",
+ "Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.8.4)\n",
+ "Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.11)\n",
+ "Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.0)\n",
+ "Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.1.2)\n",
+ "Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (4.1.0)\n",
+ "Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.5.0)\n",
+ "Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.1)\n",
+ "Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.3)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (3.0.7)\n",
+ "Requirement already satisfied: executing in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.8.2)\n",
+ "Requirement already satisfied: pure-eval in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.2.2)\n",
+ "Requirement already satisfied: asttokens in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (2.0.5)\n",
+ "Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets\n",
+ "Successfully installed ipywidgets-7.7.0 jupyterlab-widgets-1.1.0 widgetsnbextension-3.6.0\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install scikit-image==0.19.1\n",
+ "!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "\n",
+ "## 2. SSD\n",
+ "\n",
+ "### Single Shot MultiBox Detector model for object detection\n",
+ "\n",
+ "_ | _\n",
+ "- | -\n",
+ " | "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "PyTorch has a model repository called the PyTorch Hub, which is a source for high quality implementations of common models. We can get our SSD model pretrained on [COCO](https://cocodataset.org/#home) from there.\n",
+ "\n",
+ "### Model Description\n",
+ "\n",
+ "This SSD300 model is based on the\n",
+ "[SSD: Single Shot MultiBox Detector](https://arxiv.org/abs/1512.02325) paper, which\n",
+ "describes SSD as “a method for detecting objects in images using a single deep neural network\".\n",
+ "The input size is fixed to 300x300.\n",
+ "\n",
+ "The main difference between this model and the one described in the paper is in the backbone.\n",
+ "Specifically, the VGG model is obsolete and is replaced by the ResNet-50 model.\n",
+ "\n",
+ "From the\n",
+ "[Speed/accuracy trade-offs for modern convolutional object detectors](https://arxiv.org/abs/1611.10012)\n",
+ "paper, the following enhancements were made to the backbone:\n",
+ "* The conv5_x, avgpool, fc and softmax layers were removed from the original classification model.\n",
+ "* All strides in conv4_x are set to 1x1.\n",
+ "\n",
+ "The backbone is followed by 5 additional convolutional layers.\n",
+ "In addition to the convolutional layers, we attached 6 detection heads:\n",
+ "* The first detection head is attached to the last conv4_x layer.\n",
+ "* The other five detection heads are attached to the corresponding 5 additional layers.\n",
+ "\n",
+ "Detector heads are similar to the ones referenced in the paper, however,\n",
+ "they are enhanced by additional BatchNorm layers after each convolution.\n",
+ "\n",
+ "More information about this SSD model is available at Nvidia's \"DeepLearningExamples\" Github [here](https://github.com/NVIDIA/DeepLearningExamples/tree/master/PyTorch/Detection/SSD)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "torch.hub._validate_not_a_forked_repo=lambda a,b,c: True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Downloading: \"https://github.com/NVIDIA/DeepLearningExamples/archive/torchhub.zip\" to /root/.cache/torch/hub/torchhub.zip\n",
+ "/root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub/PyTorch/Classification/ConvNets/image_classification/models/efficientnet.py:17: UserWarning: pytorch_quantization module not found, quantization will not be available\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "['nvidia_convnets_processing_utils',\n",
+ " 'nvidia_efficientnet',\n",
+ " 'nvidia_efficientnet_b0',\n",
+ " 'nvidia_efficientnet_b4',\n",
+ " 'nvidia_efficientnet_widese_b0',\n",
+ " 'nvidia_efficientnet_widese_b4',\n",
+ " 'nvidia_resneXt',\n",
+ " 'nvidia_resnet50',\n",
+ " 'nvidia_resnext101_32x4d',\n",
+ " 'nvidia_se_resnext101_32x4d',\n",
+ " 'nvidia_ssd',\n",
+ " 'nvidia_ssd_processing_utils',\n",
+ " 'nvidia_tacotron2',\n",
+ " 'nvidia_tts_utils',\n",
+ " 'nvidia_waveglow']"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# List of available models in PyTorch Hub from Nvidia/DeepLearningExamples\n",
+ "torch.hub.list('NVIDIA/DeepLearningExamples:torchhub')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Using cache found in /root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub\n",
+ "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1c7cf3e1635d4a2b9c8731b7fc9ce724",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " 0%| | 0.00/97.8M [00:0040%) in a more comprehensive format.\n",
+ "results_per_input = utils.decode_results(detections_batch)\n",
+ "best_results_per_input = [utils.pick_best(results, 0.40) for results in results_per_input]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Visualize results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from matplotlib import pyplot as plt\n",
+ "import matplotlib.patches as patches\n",
+ "\n",
+ "# The utility plots the images and predicted bounding boxes (with confidence scores).\n",
+ "def plot_results(best_results):\n",
+ " for image_idx in range(len(best_results)):\n",
+ " fig, ax = plt.subplots(1)\n",
+ " # Show original, denormalized image...\n",
+ " image = inputs[image_idx] / 2 + 0.5\n",
+ " ax.imshow(image)\n",
+ " # ...with detections\n",
+ " bboxes, classes, confidences = best_results[image_idx]\n",
+ " for idx in range(len(bboxes)):\n",
+ " left, bot, right, top = bboxes[idx]\n",
+ " x, y, w, h = [val * 300 for val in [left, bot, right - left, top - bot]]\n",
+ " rect = patches.Rectangle((x, y), w, h, linewidth=1, edgecolor='r', facecolor='none')\n",
+ " ax.add_patch(rect)\n",
+ " ax.text(x, y, \"{} {:.0f}%\".format(classes_to_labels[classes[idx] - 1], confidences[idx]*100), bbox=dict(facecolor='white', alpha=0.5))\n",
+ " plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "+ Quantization Aware training (QAT) simulates quantization during training by quantizing weights and activation layers. This will help to reduce the loss in accuracy when we convert the network trained in FP32 to INT8 for faster inference. QAT introduces additional nodes in the graph which will be used to learn the dynamic ranges of weights and activation layers. In this notebook, we illustrate the following steps from training to inference of a QAT model in Torch-TensorRT. +
++ + Requirements + +
++ + References + +
++ ## 1. Requirements Please install the required dependencies and import these libraries accordingly +
+[ ]:
+
+
+!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org
+
+ [1]:
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import torch.utils.data as data
+import torchvision.transforms as transforms
+import torchvision.datasets as datasets
+import torch_tensorrt
+
+from torch.utils.tensorboard import SummaryWriter
+
+import pytorch_quantization
+from pytorch_quantization import nn as quant_nn
+from pytorch_quantization import quant_modules
+from pytorch_quantization.tensor_quant import QuantDescriptor
+from pytorch_quantization import calib
+from tqdm import tqdm
+
+print(pytorch_quantization.__version__)
+
+import os
+import sys
+sys.path.insert(0, "../examples/int8/training/vgg16")
+from vgg16 import vgg16
+
+
+
+2.1.0
+
+
+ ## 2. VGG16 Overview ### Very Deep Convolutional Networks for Large-Scale Image Recognition VGG is one of the earliest family of image classification networks that first used small (3x3) convolution filters and achieved significant improvements on ImageNet recognition challenge. The network architecture looks as follows
+ 
+
+ ## 3. Training a baseline VGG16 model We train VGG16 on CIFAR10 dataset. Define training and testing datasets and dataloaders. This will download the CIFAR 10 data in your
+
+
+ data
+
+
+ directory. Data preprocessing is performed using
+
+
+ torchvision
+
+
+ transforms.
+
[2]:
+
+
+classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+# ========== Define Training dataset and dataloaders =============#
+training_dataset = datasets.CIFAR10(root='./data',
+ train=True,
+ download=True,
+ transform=transforms.Compose([
+ transforms.RandomCrop(32, padding=4),
+ transforms.RandomHorizontalFlip(),
+ transforms.ToTensor(),
+ transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+ ]))
+
+training_dataloader = torch.utils.data.DataLoader(training_dataset,
+ batch_size=32,
+ shuffle=True,
+ num_workers=2)
+
+# ========== Define Testing dataset and dataloaders =============#
+testing_dataset = datasets.CIFAR10(root='./data',
+ train=False,
+ download=True,
+ transform=transforms.Compose([
+ transforms.ToTensor(),
+ transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+ ]))
+
+testing_dataloader = torch.utils.data.DataLoader(testing_dataset,
+ batch_size=16,
+ shuffle=False,
+ num_workers=2)
+
+
+
+Files already downloaded and verified
+Files already downloaded and verified
+
+ [3]:
+
+
+def train(model, dataloader, crit, opt, epoch):
+# global writer
+ model.train()
+ running_loss = 0.0
+ for batch, (data, labels) in enumerate(dataloader):
+ data, labels = data.cuda(), labels.cuda(non_blocking=True)
+ opt.zero_grad()
+ out = model(data)
+ loss = crit(out, labels)
+ loss.backward()
+ opt.step()
+
+ running_loss += loss.item()
+ if batch % 500 == 499:
+ print("Batch: [%5d | %5d] loss: %.3f" % (batch + 1, len(dataloader), running_loss / 100))
+ running_loss = 0.0
+
+def test(model, dataloader, crit, epoch):
+ global writer
+ global classes
+ total = 0
+ correct = 0
+ loss = 0.0
+ class_probs = []
+ class_preds = []
+ model.eval()
+ with torch.no_grad():
+ for data, labels in dataloader:
+ data, labels = data.cuda(), labels.cuda(non_blocking=True)
+ out = model(data)
+ loss += crit(out, labels)
+ preds = torch.max(out, 1)[1]
+ class_probs.append([F.softmax(i, dim=0) for i in out])
+ class_preds.append(preds)
+ total += labels.size(0)
+ correct += (preds == labels).sum().item()
+
+ test_probs = torch.cat([torch.stack(batch) for batch in class_probs])
+ test_preds = torch.cat(class_preds)
+
+ return loss / total, correct / total
+
+def save_checkpoint(state, ckpt_path="checkpoint.pth"):
+ torch.save(state, ckpt_path)
+ print("Checkpoint saved")
+
+ + + Define the VGG model that we are going to perfom QAT on. + +
+[4]:
+
+
+# CIFAR 10 has 10 classes
+model = vgg16(num_classes=len(classes), init_weights=False)
+model = model.cuda()
+
+ [5]:
+
+
+# Declare Learning rate
+lr = 0.1
+state = {}
+state["lr"] = lr
+
+# Use cross entropy loss for classification and SGD optimizer
+crit = nn.CrossEntropyLoss()
+opt = optim.SGD(model.parameters(), lr=state["lr"], momentum=0.9, weight_decay=1e-4)
+
+
+# Adjust learning rate based on epoch number
+def adjust_lr(optimizer, epoch):
+ global state
+ new_lr = lr * (0.5**(epoch // 12)) if state["lr"] > 1e-7 else state["lr"]
+ if new_lr != state["lr"]:
+ state["lr"] = new_lr
+ print("Updating learning rate: {}".format(state["lr"]))
+ for param_group in optimizer.param_groups:
+ param_group["lr"] = state["lr"]
+
+ [6]:
+
+
+# Train the model for 25 epochs to get ~80% accuracy.
+num_epochs=25
+for epoch in range(num_epochs):
+ adjust_lr(opt, epoch)
+ print('Epoch: [%5d / %5d] LR: %f' % (epoch + 1, num_epochs, state["lr"]))
+
+ train(model, training_dataloader, crit, opt, epoch)
+ test_loss, test_acc = test(model, testing_dataloader, crit, epoch)
+
+ print("Test Loss: {:.5f} Test Acc: {:.2f}%".format(test_loss, 100 * test_acc))
+
+save_checkpoint({'epoch': epoch + 1,
+ 'model_state_dict': model.state_dict(),
+ 'acc': test_acc,
+ 'opt_state_dict': opt.state_dict(),
+ 'state': state},
+ ckpt_path="vgg16_base_ckpt")
+
+
+Epoch: [ 1 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 13.288
+Batch: [ 1000 | 1563] loss: 11.345
+Batch: [ 1500 | 1563] loss: 11.008
+Test Loss: 0.13388 Test Acc: 13.23%
+Epoch: [ 2 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 10.742
+Batch: [ 1000 | 1563] loss: 10.311
+Batch: [ 1500 | 1563] loss: 10.141
+Test Loss: 0.11888 Test Acc: 23.96%
+Epoch: [ 3 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 9.877
+Batch: [ 1000 | 1563] loss: 9.821
+Batch: [ 1500 | 1563] loss: 9.818
+Test Loss: 0.11879 Test Acc: 24.68%
+Epoch: [ 4 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 9.677
+Batch: [ 1000 | 1563] loss: 9.613
+Batch: [ 1500 | 1563] loss: 9.504
+Test Loss: 0.11499 Test Acc: 23.68%
+Epoch: [ 5 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 9.560
+Batch: [ 1000 | 1563] loss: 9.536
+Batch: [ 1500 | 1563] loss: 9.309
+Test Loss: 0.10990 Test Acc: 27.84%
+Epoch: [ 6 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 9.254
+Batch: [ 1000 | 1563] loss: 9.234
+Batch: [ 1500 | 1563] loss: 9.188
+Test Loss: 0.11594 Test Acc: 23.29%
+Epoch: [ 7 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 9.141
+Batch: [ 1000 | 1563] loss: 9.110
+Batch: [ 1500 | 1563] loss: 9.013
+Test Loss: 0.10732 Test Acc: 29.24%
+Epoch: [ 8 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 9.120
+Batch: [ 1000 | 1563] loss: 9.086
+Batch: [ 1500 | 1563] loss: 8.948
+Test Loss: 0.10732 Test Acc: 27.24%
+Epoch: [ 9 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 8.941
+Batch: [ 1000 | 1563] loss: 8.997
+Batch: [ 1500 | 1563] loss: 9.028
+Test Loss: 0.11299 Test Acc: 25.52%
+Epoch: [ 10 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 8.927
+Batch: [ 1000 | 1563] loss: 8.837
+Batch: [ 1500 | 1563] loss: 8.860
+Test Loss: 0.10130 Test Acc: 34.61%
+Epoch: [ 11 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 8.953
+Batch: [ 1000 | 1563] loss: 8.738
+Batch: [ 1500 | 1563] loss: 8.724
+Test Loss: 0.10018 Test Acc: 32.27%
+Epoch: [ 12 / 25] LR: 0.100000
+Batch: [ 500 | 1563] loss: 8.721
+Batch: [ 1000 | 1563] loss: 8.716
+Batch: [ 1500 | 1563] loss: 8.701
+Test Loss: 0.10070 Test Acc: 29.57%
+Updating learning rate: 0.05
+Epoch: [ 13 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 7.944
+Batch: [ 1000 | 1563] loss: 7.649
+Batch: [ 1500 | 1563] loss: 7.511
+Test Loss: 0.08555 Test Acc: 44.62%
+Epoch: [ 14 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 7.057
+Batch: [ 1000 | 1563] loss: 6.944
+Batch: [ 1500 | 1563] loss: 6.687
+Test Loss: 0.08331 Test Acc: 52.27%
+Epoch: [ 15 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 6.470
+Batch: [ 1000 | 1563] loss: 6.439
+Batch: [ 1500 | 1563] loss: 6.126
+Test Loss: 0.07266 Test Acc: 58.02%
+Epoch: [ 16 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 5.834
+Batch: [ 1000 | 1563] loss: 5.801
+Batch: [ 1500 | 1563] loss: 5.622
+Test Loss: 0.06340 Test Acc: 65.17%
+Epoch: [ 17 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 5.459
+Batch: [ 1000 | 1563] loss: 5.442
+Batch: [ 1500 | 1563] loss: 5.314
+Test Loss: 0.05945 Test Acc: 67.22%
+Epoch: [ 18 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 5.071
+Batch: [ 1000 | 1563] loss: 5.145
+Batch: [ 1500 | 1563] loss: 5.063
+Test Loss: 0.06567 Test Acc: 64.46%
+Epoch: [ 19 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 4.796
+Batch: [ 1000 | 1563] loss: 4.781
+Batch: [ 1500 | 1563] loss: 4.732
+Test Loss: 0.05374 Test Acc: 71.87%
+Epoch: [ 20 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 4.568
+Batch: [ 1000 | 1563] loss: 4.564
+Batch: [ 1500 | 1563] loss: 4.484
+Test Loss: 0.05311 Test Acc: 71.12%
+Epoch: [ 21 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 4.385
+Batch: [ 1000 | 1563] loss: 4.302
+Batch: [ 1500 | 1563] loss: 4.285
+Test Loss: 0.05080 Test Acc: 74.29%
+Epoch: [ 22 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 4.069
+Batch: [ 1000 | 1563] loss: 4.105
+Batch: [ 1500 | 1563] loss: 4.096
+Test Loss: 0.04807 Test Acc: 75.20%
+Epoch: [ 23 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 3.959
+Batch: [ 1000 | 1563] loss: 3.898
+Batch: [ 1500 | 1563] loss: 3.916
+Test Loss: 0.04743 Test Acc: 75.81%
+Epoch: [ 24 / 25] LR: 0.050000
+Batch: [ 500 | 1563] loss: 3.738
+Batch: [ 1000 | 1563] loss: 3.847
+Batch: [ 1500 | 1563] loss: 3.797
+Test Loss: 0.04609 Test Acc: 76.42%
+Updating learning rate: 0.025
+Epoch: [ 25 / 25] LR: 0.025000
+Batch: [ 500 | 1563] loss: 2.952
+Batch: [ 1000 | 1563] loss: 2.906
+Batch: [ 1500 | 1563] loss: 2.735
+Test Loss: 0.03466 Test Acc: 82.00%
+Checkpoint saved
+
+ + ## 4. Apply Quantization +
+
+
+
+ quant_modules.initialize()
+
+
+ will ensure quantized version of modules will be called instead of original modules. For example, when you define a model with convolution, linear, pooling layers,
+
+
+ QuantConv2d
+
+
+ ,
+
+
+ QuantLinear
+
+
+ and
+
+
+ QuantPooling
+
+
+ will be called.
+
+
+ QuantConv2d
+
+
+ basically wraps quantizer nodes around inputs and weights of regular
+
+
+ Conv2d
+
+
+ . Please refer to all the quantized modules in pytorch-quantization toolkit for more information. A
+
+
+ QuantConv2d
+
+
+ is represented in
+
+
+ pytorch-quantization
+
+
+ toolkit as follows.
+
def forward(self, input):
+ # the actual quantization happens in the next level of the class hierarchy
+ quant_input, quant_weight = self._quant(input)
+
+ if self.padding_mode == 'circular':
+ expanded_padding = ((self.padding[1] + 1) // 2, self.padding[1] // 2,
+ (self.padding[0] + 1) // 2, self.padding[0] // 2)
+ output = F.conv2d(F.pad(quant_input, expanded_padding, mode='circular'),
+ quant_weight, self.bias, self.stride,
+ _pair(0), self.dilation, self.groups)
+ else:
+ output = F.conv2d(quant_input, quant_weight, self.bias, self.stride, self.padding, self.dilation,
+ self.groups)
+
+ return output
+
+ [7]:
+
+
+quant_modules.initialize()
+
+ [8]:
+
+
+# All the regular conv, FC layers will be converted to their quantozed counterparts due to quant_modules.initialize()
+qat_model = vgg16(num_classes=len(classes), init_weights=False)
+qat_model = qat_model.cuda()
+
+ [9]:
+
+
+# vgg16_base_ckpt is the checkpoint generated from Step 3 : Training a baseline VGG16 model.
+ckpt = torch.load("./vgg16_base_ckpt")
+modified_state_dict={}
+for key, val in ckpt["model_state_dict"].items():
+ # Remove 'module.' from the key names
+ if key.startswith('module'):
+ modified_state_dict[key[7:]] = val
+ else:
+ modified_state_dict[key] = val
+
+# Load the pre-trained checkpoint
+qat_model.load_state_dict(modified_state_dict)
+opt.load_state_dict(ckpt["opt_state_dict"])
+
+ + ## 5. Model Calibration +
+
+ The quantizer nodes introduced in the model around desired layers capture the dynamic range (min_value, max_value) that is observed by the layer. Calibration is the process of computing the dynamic range of these layers by passing calibration data, which is usually a subset of training or validation data. There are different ways of calibration:
+
+
+ max
+
+
+ ,
+
+
+ histogram
+
+
+ and
+
+
+ entropy
+
+
+ . We use
+
+
+ max
+
+
+ calibration technique as it is simple and effective.
+
[10]:
+
+
+def compute_amax(model, **kwargs):
+ # Load calib result
+ for name, module in model.named_modules():
+ if isinstance(module, quant_nn.TensorQuantizer):
+ if module._calibrator is not None:
+ if isinstance(module._calibrator, calib.MaxCalibrator):
+ module.load_calib_amax()
+ else:
+ module.load_calib_amax(**kwargs)
+ print(F"{name:40}: {module}")
+ model.cuda()
+
+def collect_stats(model, data_loader, num_batches):
+ """Feed data to the network and collect statistics"""
+ # Enable calibrators
+ for name, module in model.named_modules():
+ if isinstance(module, quant_nn.TensorQuantizer):
+ if module._calibrator is not None:
+ module.disable_quant()
+ module.enable_calib()
+ else:
+ module.disable()
+
+ # Feed data to the network for collecting stats
+ for i, (image, _) in tqdm(enumerate(data_loader), total=num_batches):
+ model(image.cuda())
+ if i >= num_batches:
+ break
+
+ # Disable calibrators
+ for name, module in model.named_modules():
+ if isinstance(module, quant_nn.TensorQuantizer):
+ if module._calibrator is not None:
+ module.enable_quant()
+ module.disable_calib()
+ else:
+ module.enable()
+
+def calibrate_model(model, model_name, data_loader, num_calib_batch, calibrator, hist_percentile, out_dir):
+ """
+ Feed data to the network and calibrate.
+ Arguments:
+ model: classification model
+ model_name: name to use when creating state files
+ data_loader: calibration data set
+ num_calib_batch: amount of calibration passes to perform
+ calibrator: type of calibration to use (max/histogram)
+ hist_percentile: percentiles to be used for historgram calibration
+ out_dir: dir to save state files in
+ """
+
+ if num_calib_batch > 0:
+ print("Calibrating model")
+ with torch.no_grad():
+ collect_stats(model, data_loader, num_calib_batch)
+
+ if not calibrator == "histogram":
+ compute_amax(model, method="max")
+ calib_output = os.path.join(
+ out_dir,
+ F"{model_name}-max-{num_calib_batch*data_loader.batch_size}.pth")
+ torch.save(model.state_dict(), calib_output)
+ else:
+ for percentile in hist_percentile:
+ print(F"{percentile} percentile calibration")
+ compute_amax(model, method="percentile")
+ calib_output = os.path.join(
+ out_dir,
+ F"{model_name}-percentile-{percentile}-{num_calib_batch*data_loader.batch_size}.pth")
+ torch.save(model.state_dict(), calib_output)
+
+ for method in ["mse", "entropy"]:
+ print(F"{method} calibration")
+ compute_amax(model, method=method)
+ calib_output = os.path.join(
+ out_dir,
+ F"{model_name}-{method}-{num_calib_batch*data_loader.batch_size}.pth")
+ torch.save(model.state_dict(), calib_output)
+
+ [11]:
+
+
+#Calibrate the model using max calibration technique.
+with torch.no_grad():
+ calibrate_model(
+ model=qat_model,
+ model_name="vgg16",
+ data_loader=training_dataloader,
+ num_calib_batch=32,
+ calibrator="max",
+ hist_percentile=[99.9, 99.99, 99.999, 99.9999],
+ out_dir="./")
+
+
+Calibrating model
+
+
+100%|███████████████████████████████████████████████████████| 32/32 [00:00<00:00, 96.04it/s]
+WARNING: Logging before flag parsing goes to stderr.
+W1109 04:01:43.512364 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.513354 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.514046 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.514638 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.515270 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.515859 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.516441 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.517009 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.517600 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.518167 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.518752 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.519333 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.519911 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.520473 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.521038 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.521596 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.522170 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.522742 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.523360 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.523957 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.524581 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.525059 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.525366 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.525675 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.525962 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.526257 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.526566 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.526885 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.527188 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.527489 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.527792 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.528097 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.528387 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator
+W1109 04:01:43.528834 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.529163 139704147265344 tensor_quantizer.py:238] Call .cuda() if running on GPU after loading calibrated amax.
+W1109 04:01:43.532748 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([64, 1, 1, 1]).
+W1109 04:01:43.533468 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.534033 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([64, 1, 1, 1]).
+W1109 04:01:43.534684 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.535320 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([128, 1, 1, 1]).
+W1109 04:01:43.535983 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.536569 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([128, 1, 1, 1]).
+W1109 04:01:43.537248 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.537833 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).
+W1109 04:01:43.538480 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.539074 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).
+W1109 04:01:43.539724 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.540307 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).
+W1109 04:01:43.540952 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.541534 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).
+W1109 04:01:43.542075 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.542596 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).
+W1109 04:01:43.543248 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.543719 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).
+W1109 04:01:43.544424 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.544952 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).
+W1109 04:01:43.545530 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.546114 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).
+W1109 04:01:43.546713 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.547292 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).
+W1109 04:01:43.547902 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.548453 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.549015 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([4096, 1]).
+W1109 04:01:43.549665 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.550436 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([4096, 1]).
+W1109 04:01:43.551925 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).
+W1109 04:01:43.553105 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([10, 1]).
+
+
+features.0._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=2.7537 calibrator=MaxCalibrator scale=1.0 quant)
+features.0._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0263, 2.7454](64) calibrator=MaxCalibrator scale=1.0 quant)
+features.3._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=27.5676 calibrator=MaxCalibrator scale=1.0 quant)
+features.3._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0169, 1.8204](64) calibrator=MaxCalibrator scale=1.0 quant)
+features.7._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=15.2002 calibrator=MaxCalibrator scale=1.0 quant)
+features.7._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0493, 1.3207](128) calibrator=MaxCalibrator scale=1.0 quant)
+features.10._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=7.7376 calibrator=MaxCalibrator scale=1.0 quant)
+features.10._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0163, 0.9624](128) calibrator=MaxCalibrator scale=1.0 quant)
+features.14._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=8.8351 calibrator=MaxCalibrator scale=1.0 quant)
+features.14._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0622, 0.8791](256) calibrator=MaxCalibrator scale=1.0 quant)
+features.17._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=12.5746 calibrator=MaxCalibrator scale=1.0 quant)
+features.17._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0505, 0.5117](256) calibrator=MaxCalibrator scale=1.0 quant)
+features.20._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=9.7203 calibrator=MaxCalibrator scale=1.0 quant)
+features.20._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0296, 0.5335](256) calibrator=MaxCalibrator scale=1.0 quant)
+features.24._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=8.9367 calibrator=MaxCalibrator scale=1.0 quant)
+features.24._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0220, 0.3763](512) calibrator=MaxCalibrator scale=1.0 quant)
+features.27._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=6.6539 calibrator=MaxCalibrator scale=1.0 quant)
+features.27._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0151, 0.1777](512) calibrator=MaxCalibrator scale=1.0 quant)
+features.30._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=3.7099 calibrator=MaxCalibrator scale=1.0 quant)
+features.30._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0087, 0.1906](512) calibrator=MaxCalibrator scale=1.0 quant)
+features.34._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=4.0491 calibrator=MaxCalibrator scale=1.0 quant)
+features.34._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0106, 0.1971](512) calibrator=MaxCalibrator scale=1.0 quant)
+features.37._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=2.1531 calibrator=MaxCalibrator scale=1.0 quant)
+features.37._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0070, 0.2305](512) calibrator=MaxCalibrator scale=1.0 quant)
+features.40._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=3.3631 calibrator=MaxCalibrator scale=1.0 quant)
+features.40._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0023, 0.4726](512) calibrator=MaxCalibrator scale=1.0 quant)
+avgpool._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=5.3550 calibrator=MaxCalibrator scale=1.0 quant)
+classifier.0._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=5.3550 calibrator=MaxCalibrator scale=1.0 quant)
+classifier.0._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0026, 0.5320](4096) calibrator=MaxCalibrator scale=1.0 quant)
+classifier.3._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=6.6733 calibrator=MaxCalibrator scale=1.0 quant)
+classifier.3._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0018, 0.5172](4096) calibrator=MaxCalibrator scale=1.0 quant)
+classifier.6._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=9.4352 calibrator=MaxCalibrator scale=1.0 quant)
+classifier.6._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.3877, 0.5620](10) calibrator=MaxCalibrator scale=1.0 quant)
+
+ + ## 6. Quantization Aware Training +
+
+ In this phase, we finetune the model weights and leave the quantizer node values frozen. The dynamic ranges for each layer obtained from the calibration are kept constant while the weights of the model are finetuned to be close to the accuracy of original FP32 model (model without quantizer nodes) is preserved. Usually the finetuning of QAT model should be quick compared to the full training of the original model. Use QAT to fine-tune for around 10% of the original training schedule with an
+annealing learning-rate. Please refer to Achieving FP32 Accuracy for INT8 Inference Using Quantization Aware Training with NVIDIA TensorRT for detailed recommendations. For this VGG model, it is enough to finetune for 1 epoch to get acceptable accuracy. During finetuning with QAT, the quantization is applied as a composition of
+
+
+ max
+
+
+ ,
+
+
+ clamp
+
+
+ ,
+
+
+ round
+
+
+ and
+
+
+ mul
+
+
+ ops.
+
# amax is absolute maximum value for an input
+# The upper bound for integer quantization (127 for int8)
+max_bound = torch.tensor((2.0**(num_bits - 1 + int(unsigned))) - 1.0, device=amax.device)
+scale = max_bound / amax
+outputs = torch.clamp((inputs * scale).round_(), min_bound, max_bound)
+
+
+ tensor_quant function in
+
+
+ pytorch_quantization
+
+
+ toolkit is responsible for the above tensor quantization. Usually, per channel quantization is recommended for weights, while per tensor quantization is recommended for activations in a network. During inference, we use
+
+
+ torch.fake_quantize_per_tensor_affine
+
+
+ and
+
+
+ torch.fake_quantize_per_channel_affine
+
+
+ to perform quantization as this is easier to convert into corresponding TensorRT operators. Please refer to next sections for more details on
+how these operators are exported in torchscript and converted in Torch-TensorRT.
+
[12]:
+
+
+# Finetune the QAT model for 1 epoch
+num_epochs=1
+for epoch in range(num_epochs):
+ adjust_lr(opt, epoch)
+ print('Epoch: [%5d / %5d] LR: %f' % (epoch + 1, num_epochs, state["lr"]))
+
+ train(qat_model, training_dataloader, crit, opt, epoch)
+ test_loss, test_acc = test(qat_model, testing_dataloader, crit, epoch)
+
+ print("Test Loss: {:.5f} Test Acc: {:.2f}%".format(test_loss, 100 * test_acc))
+
+save_checkpoint({'epoch': epoch + 1,
+ 'model_state_dict': qat_model.state_dict(),
+ 'acc': test_acc,
+ 'opt_state_dict': opt.state_dict(),
+ 'state': state},
+ ckpt_path="vgg16_qat_ckpt")
+
+
+Updating learning rate: 0.1
+Epoch: [ 1 / 1] LR: 0.100000
+Batch: [ 500 | 1563] loss: 2.635
+Batch: [ 1000 | 1563] loss: 2.655
+Batch: [ 1500 | 1563] loss: 2.646
+Test Loss: 0.03291 Test Acc: 82.98%
+Checkpoint saved
+
+
+ ## 7. Export to Torchscript Export the model to Torch script. Trace the model and convert it into torchscript for deployment. To learn more about Torchscript, please refer to
+
+ https://pytorch.org/docs/stable/jit.html
+
+ . Setting
+
+
+ quant_nn.TensorQuantizer.use_fb_fake_quant
+
+
+ =
+
+
+ True
+
+
+ enables the QAT model to use
+
+
+ torch.fake_quantize_per_tensor_affine
+
+
+ and
+
+
+ torch.fake_quantize_per_channel_affine
+
+
+ operators instead of
+
+
+ tensor_quant
+
+
+ function to export quantization operators. In torchscript, they
+are represented as
+
+
+ aten::fake_quantize_per_tensor_affine
+
+
+ and
+
+
+ aten::fake_quantize_per_channel_affine
+
+
+ .
+
[13]:
+
+
+quant_nn.TensorQuantizer.use_fb_fake_quant = True
+with torch.no_grad():
+ data = iter(testing_dataloader)
+ images, _ = data.next()
+ jit_model = torch.jit.trace(qat_model, images.to("cuda"))
+ torch.jit.save(jit_model, "trained_vgg16_qat.jit.pt")
+
+
+E1109 04:02:37.101168 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.102248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.107194 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.107625 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.115269 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.115740 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.117969 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.118358 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.126382 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.126834 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.128674 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.129518 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.135453 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.135936 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.137858 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.138366 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.145539 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.146053 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.147871 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.148353 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.154252 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.154685 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.156558 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.157159 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.163197 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.163676 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.165549 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.165991 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.173305 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.173926 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.176034 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.176697 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.182843 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.183426 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.185377 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.185962 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.191966 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.192424 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.194325 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.194817 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.201988 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.202665 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.204763 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.205461 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.211393 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.211987 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.213899 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.214450 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.220892 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.221533 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.223519 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.224037 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.233809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.234434 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.238212 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.239042 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.241022 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.241654 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.247820 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.248445 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.250366 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.250959 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.257248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.257854 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.259968 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.260660 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+W1109 04:02:37.268160 139704147265344 tensor_quantizer.py:280] Use Pytorch's native experimental fake quantization.
+/opt/conda/lib/python3.8/site-packages/pytorch_quantization/nn/modules/tensor_quantizer.py:285: TracerWarning: Converting a tensor to a Python number might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!
+ inputs, amax.item() / bound, 0,
+/opt/conda/lib/python3.8/site-packages/pytorch_quantization/nn/modules/tensor_quantizer.py:291: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!
+ quant_dim = list(amax.shape).index(list(amax_sequeeze.shape)[0])
+E1109 04:02:37.329273 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.330212 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.332529 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.333365 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.339547 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.340248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.342257 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.342890 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.350619 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.351372 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.353470 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.354121 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.360090 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.360806 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.362803 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.363274 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.370369 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.371057 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.373071 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.373766 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.379890 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.380538 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.382532 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.383128 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.389077 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.389760 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.391815 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.392399 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.399809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.400472 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.402399 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.402939 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.408818 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.409424 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.411513 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.412097 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.418537 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.419128 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.421343 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.421946 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.429382 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.430156 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.432259 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.433079 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.439297 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.440027 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.442149 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.442826 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.449377 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.449968 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.452122 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.452754 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.462532 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.463295 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.466963 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.467725 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.469692 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.470336 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.476204 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.476738 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.478809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.479375 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.485666 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.486219 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.488416 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+E1109 04:02:37.488986 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!
+
+
+ ## 8. Inference using Torch-TensorRT In this phase, we run the exported torchscript graph of VGG QAT using Torch-TensorRT. Torch-TensorRT is a Pytorch-TensorRT compiler which converts Torchscript graphs into TensorRT. TensorRT 8.0 supports inference of quantization aware trained models and introduces new APIs;
+
+
+ QuantizeLayer
+
+
+ and
+
+
+ DequantizeLayer
+
+
+ . We can observe the entire VGG QAT graph quantization nodes from the debug log of Torch-TensorRT. To enable debug logging, you can set
+
+
+ torch_tensorrt.logging.set_reportable_log_level(torch_tensorrt.logging.Level.Debug)
+
+
+ . For example,
+
+
+ QuantConv2d
+
+
+ layer from
+
+
+ pytorch_quantization
+
+
+ toolkit is represented as follows in Torchscript
+
%quant_input : Tensor = aten::fake_quantize_per_tensor_affine(%x, %636, %637, %638, %639)
+%quant_weight : Tensor = aten::fake_quantize_per_channel_affine(%394, %640, %641, %637, %638, %639)
+%input.2 : Tensor = aten::_convolution(%quant_input, %quant_weight, %395, %687, %688, %689, %643, %690, %642, %643, %643, %644, %644)
+
+
+
+
+ aten::fake_quantize_per_*_affine
+
+
+ is converted into
+
+
+ QuantizeLayer
+
+
+ +
+
+
+ DequantizeLayer
+
+
+ in Torch-TensorRT internally. Please refer to quantization op converters in Torch-TensorRT.
+
[14]:
+
+
+qat_model = torch.jit.load("trained_vgg16_qat.jit.pt").eval()
+
+compile_spec = {"inputs": [torch_tensorrt.Input([16, 3, 32, 32])],
+ "enabled_precisions": torch.int8,
+ }
+trt_mod = torch_tensorrt.compile(qat_model, **compile_spec)
+
+test_loss, test_acc = test(trt_mod, testing_dataloader, crit, 0)
+print("VGG QAT accuracy using TensorRT: {:.2f}%".format(100 * test_acc))
+
+
+WARNING: [Torch-TensorRT] - Cannot infer input type from calcuations in graph for input x.2. Assuming it is Float32. If not, specify input type explicity
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter
+WARNING: [Torch-TensorRT TorchScript Conversion Context] - Detected invalid timing cache, setup a local cache instead
+
+
+VGG QAT accuracy using TensorRT: 82.97%
+
+ [15]:
+
+
+import time
+import numpy as np
+
+import torch.backends.cudnn as cudnn
+cudnn.benchmark = True
+
+# Helper function to benchmark the model
+def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=1000):
+ input_data = torch.randn(input_shape)
+ input_data = input_data.to("cuda")
+ if dtype=='fp16':
+ input_data = input_data.half()
+
+ print("Warm up ...")
+ with torch.no_grad():
+ for _ in range(nwarmup):
+ features = model(input_data)
+ torch.cuda.synchronize()
+ print("Start timing ...")
+ timings = []
+ with torch.no_grad():
+ for i in range(1, nruns+1):
+ start_time = time.time()
+ output = model(input_data)
+ torch.cuda.synchronize()
+ end_time = time.time()
+ timings.append(end_time - start_time)
+ if i%100==0:
+ print('Iteration %d/%d, avg batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))
+
+ print("Input shape:", input_data.size())
+ print("Output shape:", output.shape)
+ print('Average batch time: %.2f ms'%(np.mean(timings)*1000))
+
+
+ [16]:
+
+
+benchmark(jit_model, input_shape=(16, 3, 32, 32))
+
+
+Warm up ...
+Start timing ...
+Iteration 100/1000, avg batch time 4.83 ms
+Iteration 200/1000, avg batch time 4.83 ms
+Iteration 300/1000, avg batch time 4.83 ms
+Iteration 400/1000, avg batch time 4.83 ms
+Iteration 500/1000, avg batch time 4.83 ms
+Iteration 600/1000, avg batch time 4.83 ms
+Iteration 700/1000, avg batch time 4.83 ms
+Iteration 800/1000, avg batch time 4.83 ms
+Iteration 900/1000, avg batch time 4.83 ms
+Iteration 1000/1000, avg batch time 4.83 ms
+Input shape: torch.Size([16, 3, 32, 32])
+Output shape: torch.Size([16, 10])
+Average batch time: 4.83 ms
+
+ [17]:
+
+
+benchmark(trt_mod, input_shape=(16, 3, 32, 32))
+
+
+Warm up ...
+Start timing ...
+Iteration 100/1000, avg batch time 1.87 ms
+Iteration 200/1000, avg batch time 1.84 ms
+Iteration 300/1000, avg batch time 1.85 ms
+Iteration 400/1000, avg batch time 1.83 ms
+Iteration 500/1000, avg batch time 1.82 ms
+Iteration 600/1000, avg batch time 1.81 ms
+Iteration 700/1000, avg batch time 1.81 ms
+Iteration 800/1000, avg batch time 1.80 ms
+Iteration 900/1000, avg batch time 1.80 ms
+Iteration 1000/1000, avg batch time 1.79 ms
+Input shape: torch.Size([16, 3, 32, 32])
+Output shape: torch.Size([16, 10])
+Average batch time: 1.79 ms
+
+ + ## 9. References * Very Deep Convolution Networks for large scale Image Recognition * Achieving FP32 Accuracy for INT8 Inference Using Quantization Aware Training with NVIDIA TensorRT * QAT workflow for VGG16 * Deploying VGG QAT model in C++ using Torch-TensorRT * Pytorch-quantization toolkit from NVIDIA * Pytorch quantization toolkit userguide * Quantization basics +
+![](\"https://neurohive.io/wp-content/uploads/2018/11/vgg16-1-e1542731207177.png\")
\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a5afc49",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Training a baseline VGG16 model\n",
+ "We train VGG16 on CIFAR10 dataset. Define training and testing datasets and dataloaders. This will download the CIFAR 10 data in your `data` directory. Data preprocessing is performed using `torchvision` transforms. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "5d2c4c45",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Files already downloaded and verified\n",
+ "Files already downloaded and verified\n"
+ ]
+ }
+ ],
+ "source": [
+ "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
+ "\n",
+ "# ========== Define Training dataset and dataloaders =============#\n",
+ "training_dataset = datasets.CIFAR10(root='./data',\n",
+ " train=True,\n",
+ " download=True,\n",
+ " transform=transforms.Compose([\n",
+ " transforms.RandomCrop(32, padding=4),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
+ " ]))\n",
+ "\n",
+ "training_dataloader = torch.utils.data.DataLoader(training_dataset,\n",
+ " batch_size=32,\n",
+ " shuffle=True,\n",
+ " num_workers=2)\n",
+ "\n",
+ "# ========== Define Testing dataset and dataloaders =============#\n",
+ "testing_dataset = datasets.CIFAR10(root='./data',\n",
+ " train=False,\n",
+ " download=True,\n",
+ " transform=transforms.Compose([\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
+ " ]))\n",
+ "\n",
+ "testing_dataloader = torch.utils.data.DataLoader(testing_dataset,\n",
+ " batch_size=16,\n",
+ " shuffle=False,\n",
+ " num_workers=2)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "2bd092b3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def train(model, dataloader, crit, opt, epoch):\n",
+ "# global writer\n",
+ " model.train()\n",
+ " running_loss = 0.0\n",
+ " for batch, (data, labels) in enumerate(dataloader):\n",
+ " data, labels = data.cuda(), labels.cuda(non_blocking=True)\n",
+ " opt.zero_grad()\n",
+ " out = model(data)\n",
+ " loss = crit(out, labels)\n",
+ " loss.backward()\n",
+ " opt.step()\n",
+ "\n",
+ " running_loss += loss.item()\n",
+ " if batch % 500 == 499:\n",
+ " print(\"Batch: [%5d | %5d] loss: %.3f\" % (batch + 1, len(dataloader), running_loss / 100))\n",
+ " running_loss = 0.0\n",
+ " \n",
+ "def test(model, dataloader, crit, epoch):\n",
+ " global writer\n",
+ " global classes\n",
+ " total = 0\n",
+ " correct = 0\n",
+ " loss = 0.0\n",
+ " class_probs = []\n",
+ " class_preds = []\n",
+ " model.eval()\n",
+ " with torch.no_grad():\n",
+ " for data, labels in dataloader:\n",
+ " data, labels = data.cuda(), labels.cuda(non_blocking=True)\n",
+ " out = model(data)\n",
+ " loss += crit(out, labels)\n",
+ " preds = torch.max(out, 1)[1]\n",
+ " class_probs.append([F.softmax(i, dim=0) for i in out])\n",
+ " class_preds.append(preds)\n",
+ " total += labels.size(0)\n",
+ " correct += (preds == labels).sum().item()\n",
+ "\n",
+ " test_probs = torch.cat([torch.stack(batch) for batch in class_probs])\n",
+ " test_preds = torch.cat(class_preds)\n",
+ "\n",
+ " return loss / total, correct / total\n",
+ "\n",
+ "def save_checkpoint(state, ckpt_path=\"checkpoint.pth\"):\n",
+ " torch.save(state, ckpt_path)\n",
+ " print(\"Checkpoint saved\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c80a86cc",
+ "metadata": {},
+ "source": [
+ "*Define the VGG model that we are going to perfom QAT on.*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "8c564b8f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# CIFAR 10 has 10 classes\n",
+ "model = vgg16(num_classes=len(classes), init_weights=False)\n",
+ "model = model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "abc00452",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Declare Learning rate\n",
+ "lr = 0.1\n",
+ "state = {}\n",
+ "state[\"lr\"] = lr\n",
+ "\n",
+ "# Use cross entropy loss for classification and SGD optimizer\n",
+ "crit = nn.CrossEntropyLoss()\n",
+ "opt = optim.SGD(model.parameters(), lr=state[\"lr\"], momentum=0.9, weight_decay=1e-4)\n",
+ "\n",
+ "\n",
+ "# Adjust learning rate based on epoch number\n",
+ "def adjust_lr(optimizer, epoch):\n",
+ " global state\n",
+ " new_lr = lr * (0.5**(epoch // 12)) if state[\"lr\"] > 1e-7 else state[\"lr\"]\n",
+ " if new_lr != state[\"lr\"]:\n",
+ " state[\"lr\"] = new_lr\n",
+ " print(\"Updating learning rate: {}\".format(state[\"lr\"]))\n",
+ " for param_group in optimizer.param_groups:\n",
+ " param_group[\"lr\"] = state[\"lr\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "d80865a2",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: [ 1 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 13.288\n",
+ "Batch: [ 1000 | 1563] loss: 11.345\n",
+ "Batch: [ 1500 | 1563] loss: 11.008\n",
+ "Test Loss: 0.13388 Test Acc: 13.23%\n",
+ "Epoch: [ 2 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 10.742\n",
+ "Batch: [ 1000 | 1563] loss: 10.311\n",
+ "Batch: [ 1500 | 1563] loss: 10.141\n",
+ "Test Loss: 0.11888 Test Acc: 23.96%\n",
+ "Epoch: [ 3 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.877\n",
+ "Batch: [ 1000 | 1563] loss: 9.821\n",
+ "Batch: [ 1500 | 1563] loss: 9.818\n",
+ "Test Loss: 0.11879 Test Acc: 24.68%\n",
+ "Epoch: [ 4 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.677\n",
+ "Batch: [ 1000 | 1563] loss: 9.613\n",
+ "Batch: [ 1500 | 1563] loss: 9.504\n",
+ "Test Loss: 0.11499 Test Acc: 23.68%\n",
+ "Epoch: [ 5 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.560\n",
+ "Batch: [ 1000 | 1563] loss: 9.536\n",
+ "Batch: [ 1500 | 1563] loss: 9.309\n",
+ "Test Loss: 0.10990 Test Acc: 27.84%\n",
+ "Epoch: [ 6 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.254\n",
+ "Batch: [ 1000 | 1563] loss: 9.234\n",
+ "Batch: [ 1500 | 1563] loss: 9.188\n",
+ "Test Loss: 0.11594 Test Acc: 23.29%\n",
+ "Epoch: [ 7 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.141\n",
+ "Batch: [ 1000 | 1563] loss: 9.110\n",
+ "Batch: [ 1500 | 1563] loss: 9.013\n",
+ "Test Loss: 0.10732 Test Acc: 29.24%\n",
+ "Epoch: [ 8 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.120\n",
+ "Batch: [ 1000 | 1563] loss: 9.086\n",
+ "Batch: [ 1500 | 1563] loss: 8.948\n",
+ "Test Loss: 0.10732 Test Acc: 27.24%\n",
+ "Epoch: [ 9 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.941\n",
+ "Batch: [ 1000 | 1563] loss: 8.997\n",
+ "Batch: [ 1500 | 1563] loss: 9.028\n",
+ "Test Loss: 0.11299 Test Acc: 25.52%\n",
+ "Epoch: [ 10 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.927\n",
+ "Batch: [ 1000 | 1563] loss: 8.837\n",
+ "Batch: [ 1500 | 1563] loss: 8.860\n",
+ "Test Loss: 0.10130 Test Acc: 34.61%\n",
+ "Epoch: [ 11 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.953\n",
+ "Batch: [ 1000 | 1563] loss: 8.738\n",
+ "Batch: [ 1500 | 1563] loss: 8.724\n",
+ "Test Loss: 0.10018 Test Acc: 32.27%\n",
+ "Epoch: [ 12 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.721\n",
+ "Batch: [ 1000 | 1563] loss: 8.716\n",
+ "Batch: [ 1500 | 1563] loss: 8.701\n",
+ "Test Loss: 0.10070 Test Acc: 29.57%\n",
+ "Updating learning rate: 0.05\n",
+ "Epoch: [ 13 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 7.944\n",
+ "Batch: [ 1000 | 1563] loss: 7.649\n",
+ "Batch: [ 1500 | 1563] loss: 7.511\n",
+ "Test Loss: 0.08555 Test Acc: 44.62%\n",
+ "Epoch: [ 14 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 7.057\n",
+ "Batch: [ 1000 | 1563] loss: 6.944\n",
+ "Batch: [ 1500 | 1563] loss: 6.687\n",
+ "Test Loss: 0.08331 Test Acc: 52.27%\n",
+ "Epoch: [ 15 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 6.470\n",
+ "Batch: [ 1000 | 1563] loss: 6.439\n",
+ "Batch: [ 1500 | 1563] loss: 6.126\n",
+ "Test Loss: 0.07266 Test Acc: 58.02%\n",
+ "Epoch: [ 16 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 5.834\n",
+ "Batch: [ 1000 | 1563] loss: 5.801\n",
+ "Batch: [ 1500 | 1563] loss: 5.622\n",
+ "Test Loss: 0.06340 Test Acc: 65.17%\n",
+ "Epoch: [ 17 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 5.459\n",
+ "Batch: [ 1000 | 1563] loss: 5.442\n",
+ "Batch: [ 1500 | 1563] loss: 5.314\n",
+ "Test Loss: 0.05945 Test Acc: 67.22%\n",
+ "Epoch: [ 18 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 5.071\n",
+ "Batch: [ 1000 | 1563] loss: 5.145\n",
+ "Batch: [ 1500 | 1563] loss: 5.063\n",
+ "Test Loss: 0.06567 Test Acc: 64.46%\n",
+ "Epoch: [ 19 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.796\n",
+ "Batch: [ 1000 | 1563] loss: 4.781\n",
+ "Batch: [ 1500 | 1563] loss: 4.732\n",
+ "Test Loss: 0.05374 Test Acc: 71.87%\n",
+ "Epoch: [ 20 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.568\n",
+ "Batch: [ 1000 | 1563] loss: 4.564\n",
+ "Batch: [ 1500 | 1563] loss: 4.484\n",
+ "Test Loss: 0.05311 Test Acc: 71.12%\n",
+ "Epoch: [ 21 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.385\n",
+ "Batch: [ 1000 | 1563] loss: 4.302\n",
+ "Batch: [ 1500 | 1563] loss: 4.285\n",
+ "Test Loss: 0.05080 Test Acc: 74.29%\n",
+ "Epoch: [ 22 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.069\n",
+ "Batch: [ 1000 | 1563] loss: 4.105\n",
+ "Batch: [ 1500 | 1563] loss: 4.096\n",
+ "Test Loss: 0.04807 Test Acc: 75.20%\n",
+ "Epoch: [ 23 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 3.959\n",
+ "Batch: [ 1000 | 1563] loss: 3.898\n",
+ "Batch: [ 1500 | 1563] loss: 3.916\n",
+ "Test Loss: 0.04743 Test Acc: 75.81%\n",
+ "Epoch: [ 24 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 3.738\n",
+ "Batch: [ 1000 | 1563] loss: 3.847\n",
+ "Batch: [ 1500 | 1563] loss: 3.797\n",
+ "Test Loss: 0.04609 Test Acc: 76.42%\n",
+ "Updating learning rate: 0.025\n",
+ "Epoch: [ 25 / 25] LR: 0.025000\n",
+ "Batch: [ 500 | 1563] loss: 2.952\n",
+ "Batch: [ 1000 | 1563] loss: 2.906\n",
+ "Batch: [ 1500 | 1563] loss: 2.735\n",
+ "Test Loss: 0.03466 Test Acc: 82.00%\n",
+ "Checkpoint saved\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Train the model for 25 epochs to get ~80% accuracy.\n",
+ "num_epochs=25\n",
+ "for epoch in range(num_epochs):\n",
+ " adjust_lr(opt, epoch)\n",
+ " print('Epoch: [%5d / %5d] LR: %f' % (epoch + 1, num_epochs, state[\"lr\"]))\n",
+ "\n",
+ " train(model, training_dataloader, crit, opt, epoch)\n",
+ " test_loss, test_acc = test(model, testing_dataloader, crit, epoch)\n",
+ "\n",
+ " print(\"Test Loss: {:.5f} Test Acc: {:.2f}%\".format(test_loss, 100 * test_acc))\n",
+ " \n",
+ "save_checkpoint({'epoch': epoch + 1,\n",
+ " 'model_state_dict': model.state_dict(),\n",
+ " 'acc': test_acc,\n",
+ " 'opt_state_dict': opt.state_dict(),\n",
+ " 'state': state},\n",
+ " ckpt_path=\"vgg16_base_ckpt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e1044537",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 4. Apply Quantization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c33b7f4e",
+ "metadata": {},
+ "source": [
+ "`quant_modules.initialize()` will ensure quantized version of modules will be called instead of original modules. For example, when you define a model with convolution, linear, pooling layers, `QuantConv2d`, `QuantLinear` and `QuantPooling` will be called. `QuantConv2d` basically wraps quantizer nodes around inputs and weights of regular `Conv2d`. Please refer to all the quantized modules in pytorch-quantization toolkit for more information. A `QuantConv2d` is represented in `pytorch-quantization` toolkit as follows.\n",
+ "\n",
+ "```\n",
+ "def forward(self, input):\n",
+ " # the actual quantization happens in the next level of the class hierarchy\n",
+ " quant_input, quant_weight = self._quant(input)\n",
+ "\n",
+ " if self.padding_mode == 'circular':\n",
+ " expanded_padding = ((self.padding[1] + 1) // 2, self.padding[1] // 2,\n",
+ " (self.padding[0] + 1) // 2, self.padding[0] // 2)\n",
+ " output = F.conv2d(F.pad(quant_input, expanded_padding, mode='circular'),\n",
+ " quant_weight, self.bias, self.stride,\n",
+ " _pair(0), self.dilation, self.groups)\n",
+ " else:\n",
+ " output = F.conv2d(quant_input, quant_weight, self.bias, self.stride, self.padding, self.dilation,\n",
+ " self.groups)\n",
+ "\n",
+ " return output\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "985dc59e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "quant_modules.initialize()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "164ce8cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# All the regular conv, FC layers will be converted to their quantozed counterparts due to quant_modules.initialize()\n",
+ "qat_model = vgg16(num_classes=len(classes), init_weights=False)\n",
+ "qat_model = qat_model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "8e5f7fb5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# vgg16_base_ckpt is the checkpoint generated from Step 3 : Training a baseline VGG16 model.\n",
+ "ckpt = torch.load(\"./vgg16_base_ckpt\")\n",
+ "modified_state_dict={}\n",
+ "for key, val in ckpt[\"model_state_dict\"].items():\n",
+ " # Remove 'module.' from the key names\n",
+ " if key.startswith('module'):\n",
+ " modified_state_dict[key[7:]] = val\n",
+ " else:\n",
+ " modified_state_dict[key] = val\n",
+ "\n",
+ "# Load the pre-trained checkpoint\n",
+ "qat_model.load_state_dict(modified_state_dict)\n",
+ "opt.load_state_dict(ckpt[\"opt_state_dict\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8f8a74e8",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 5. Model Calibration"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2a321f9",
+ "metadata": {},
+ "source": [
+ "The quantizer nodes introduced in the model around desired layers capture the dynamic range (min_value, max_value) that is observed by the layer. Calibration is the process of computing the dynamic range of these layers by passing calibration data, which is usually a subset of training or validation data. There are different ways of calibration: `max`, `histogram` and `entropy`. We use `max` calibration technique as it is simple and effective. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "039423dc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def compute_amax(model, **kwargs):\n",
+ " # Load calib result\n",
+ " for name, module in model.named_modules():\n",
+ " if isinstance(module, quant_nn.TensorQuantizer):\n",
+ " if module._calibrator is not None:\n",
+ " if isinstance(module._calibrator, calib.MaxCalibrator):\n",
+ " module.load_calib_amax()\n",
+ " else:\n",
+ " module.load_calib_amax(**kwargs)\n",
+ " print(F\"{name:40}: {module}\")\n",
+ " model.cuda()\n",
+ "\n",
+ "def collect_stats(model, data_loader, num_batches):\n",
+ " \"\"\"Feed data to the network and collect statistics\"\"\"\n",
+ " # Enable calibrators\n",
+ " for name, module in model.named_modules():\n",
+ " if isinstance(module, quant_nn.TensorQuantizer):\n",
+ " if module._calibrator is not None:\n",
+ " module.disable_quant()\n",
+ " module.enable_calib()\n",
+ " else:\n",
+ " module.disable()\n",
+ "\n",
+ " # Feed data to the network for collecting stats\n",
+ " for i, (image, _) in tqdm(enumerate(data_loader), total=num_batches):\n",
+ " model(image.cuda())\n",
+ " if i >= num_batches:\n",
+ " break\n",
+ "\n",
+ " # Disable calibrators\n",
+ " for name, module in model.named_modules():\n",
+ " if isinstance(module, quant_nn.TensorQuantizer):\n",
+ " if module._calibrator is not None:\n",
+ " module.enable_quant()\n",
+ " module.disable_calib()\n",
+ " else:\n",
+ " module.enable()\n",
+ "\n",
+ "def calibrate_model(model, model_name, data_loader, num_calib_batch, calibrator, hist_percentile, out_dir):\n",
+ " \"\"\"\n",
+ " Feed data to the network and calibrate.\n",
+ " Arguments:\n",
+ " model: classification model\n",
+ " model_name: name to use when creating state files\n",
+ " data_loader: calibration data set\n",
+ " num_calib_batch: amount of calibration passes to perform\n",
+ " calibrator: type of calibration to use (max/histogram)\n",
+ " hist_percentile: percentiles to be used for historgram calibration\n",
+ " out_dir: dir to save state files in\n",
+ " \"\"\"\n",
+ "\n",
+ " if num_calib_batch > 0:\n",
+ " print(\"Calibrating model\")\n",
+ " with torch.no_grad():\n",
+ " collect_stats(model, data_loader, num_calib_batch)\n",
+ "\n",
+ " if not calibrator == \"histogram\":\n",
+ " compute_amax(model, method=\"max\")\n",
+ " calib_output = os.path.join(\n",
+ " out_dir,\n",
+ " F\"{model_name}-max-{num_calib_batch*data_loader.batch_size}.pth\")\n",
+ " torch.save(model.state_dict(), calib_output)\n",
+ " else:\n",
+ " for percentile in hist_percentile:\n",
+ " print(F\"{percentile} percentile calibration\")\n",
+ " compute_amax(model, method=\"percentile\")\n",
+ " calib_output = os.path.join(\n",
+ " out_dir,\n",
+ " F\"{model_name}-percentile-{percentile}-{num_calib_batch*data_loader.batch_size}.pth\")\n",
+ " torch.save(model.state_dict(), calib_output)\n",
+ "\n",
+ " for method in [\"mse\", \"entropy\"]:\n",
+ " print(F\"{method} calibration\")\n",
+ " compute_amax(model, method=method)\n",
+ " calib_output = os.path.join(\n",
+ " out_dir,\n",
+ " F\"{model_name}-{method}-{num_calib_batch*data_loader.batch_size}.pth\")\n",
+ " torch.save(model.state_dict(), calib_output)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "78504a6f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Calibrating model\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|███████████████████████████████████████████████████████| 32/32 [00:00<00:00, 96.04it/s]\n",
+ "WARNING: Logging before flag parsing goes to stderr.\n",
+ "W1109 04:01:43.512364 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.513354 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.514046 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.514638 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.515270 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.515859 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.516441 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.517009 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.517600 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.518167 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.518752 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.519333 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.519911 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.520473 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.521038 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.521596 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.522170 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.522742 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.523360 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.523957 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.524581 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525059 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525366 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525675 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525962 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.526257 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.526566 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.526885 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.527188 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.527489 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.527792 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.528097 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.528387 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.528834 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.529163 139704147265344 tensor_quantizer.py:238] Call .cuda() if running on GPU after loading calibrated amax.\n",
+ "W1109 04:01:43.532748 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([64, 1, 1, 1]).\n",
+ "W1109 04:01:43.533468 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.534033 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([64, 1, 1, 1]).\n",
+ "W1109 04:01:43.534684 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.535320 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([128, 1, 1, 1]).\n",
+ "W1109 04:01:43.535983 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.536569 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([128, 1, 1, 1]).\n",
+ "W1109 04:01:43.537248 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.537833 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).\n",
+ "W1109 04:01:43.538480 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.539074 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).\n",
+ "W1109 04:01:43.539724 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.540307 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).\n",
+ "W1109 04:01:43.540952 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.541534 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.542075 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.542596 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.543248 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.543719 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.544424 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.544952 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.545530 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.546114 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.546713 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.547292 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.547902 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.548453 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.549015 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([4096, 1]).\n",
+ "W1109 04:01:43.549665 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.550436 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([4096, 1]).\n",
+ "W1109 04:01:43.551925 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.553105 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([10, 1]).\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "features.0._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=2.7537 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.0._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0263, 2.7454](64) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.3._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=27.5676 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.3._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0169, 1.8204](64) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.7._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=15.2002 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.7._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0493, 1.3207](128) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.10._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=7.7376 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.10._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0163, 0.9624](128) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.14._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=8.8351 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.14._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0622, 0.8791](256) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.17._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=12.5746 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.17._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0505, 0.5117](256) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.20._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=9.7203 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.20._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0296, 0.5335](256) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.24._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=8.9367 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.24._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0220, 0.3763](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.27._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=6.6539 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.27._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0151, 0.1777](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.30._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=3.7099 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.30._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0087, 0.1906](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.34._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=4.0491 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.34._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0106, 0.1971](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.37._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=2.1531 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.37._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0070, 0.2305](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.40._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=3.3631 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.40._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0023, 0.4726](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "avgpool._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=5.3550 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.0._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=5.3550 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.0._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0026, 0.5320](4096) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.3._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=6.6733 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.3._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0018, 0.5172](4096) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.6._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=9.4352 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.6._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.3877, 0.5620](10) calibrator=MaxCalibrator scale=1.0 quant)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Calibrate the model using max calibration technique.\n",
+ "with torch.no_grad():\n",
+ " calibrate_model(\n",
+ " model=qat_model,\n",
+ " model_name=\"vgg16\",\n",
+ " data_loader=training_dataloader,\n",
+ " num_calib_batch=32,\n",
+ " calibrator=\"max\",\n",
+ " hist_percentile=[99.9, 99.99, 99.999, 99.9999],\n",
+ " out_dir=\"./\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1aa0c109",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 6. Quantization Aware Training"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9fe8ec11",
+ "metadata": {},
+ "source": [
+ "In this phase, we finetune the model weights and leave the quantizer node values frozen. The dynamic ranges for each layer obtained from the calibration are kept constant while the weights of the model are finetuned to be close to the accuracy of original FP32 model (model without quantizer nodes) is preserved. Usually the finetuning of QAT model should be quick compared to the full training of the original model. Use QAT to fine-tune for around 10% of the original training schedule with an annealing learning-rate. Please refer to Achieving FP32 Accuracy for INT8 Inference Using Quantization Aware Training with NVIDIA TensorRT for detailed recommendations. For this VGG model, it is enough to finetune for 1 epoch to get acceptable accuracy. \n",
+ "During finetuning with QAT, the quantization is applied as a composition of `max`, `clamp`, `round` and `mul` ops. \n",
+ "```\n",
+ "# amax is absolute maximum value for an input\n",
+ "# The upper bound for integer quantization (127 for int8)\n",
+ "max_bound = torch.tensor((2.0**(num_bits - 1 + int(unsigned))) - 1.0, device=amax.device)\n",
+ "scale = max_bound / amax\n",
+ "outputs = torch.clamp((inputs * scale).round_(), min_bound, max_bound)\n",
+ "```\n",
+ "tensor_quant function in `pytorch_quantization` toolkit is responsible for the above tensor quantization. Usually, per channel quantization is recommended for weights, while per tensor quantization is recommended for activations in a network.\n",
+ "During inference, we use `torch.fake_quantize_per_tensor_affine` and `torch.fake_quantize_per_channel_affine` to perform quantization as this is easier to convert into corresponding TensorRT operators. Please refer to next sections for more details on how these operators are exported in torchscript and converted in Torch-TensorRT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "1f28d228",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Updating learning rate: 0.1\n",
+ "Epoch: [ 1 / 1] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 2.635\n",
+ "Batch: [ 1000 | 1563] loss: 2.655\n",
+ "Batch: [ 1500 | 1563] loss: 2.646\n",
+ "Test Loss: 0.03291 Test Acc: 82.98%\n",
+ "Checkpoint saved\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Finetune the QAT model for 1 epoch\n",
+ "num_epochs=1\n",
+ "for epoch in range(num_epochs):\n",
+ " adjust_lr(opt, epoch)\n",
+ " print('Epoch: [%5d / %5d] LR: %f' % (epoch + 1, num_epochs, state[\"lr\"]))\n",
+ "\n",
+ " train(qat_model, training_dataloader, crit, opt, epoch)\n",
+ " test_loss, test_acc = test(qat_model, testing_dataloader, crit, epoch)\n",
+ "\n",
+ " print(\"Test Loss: {:.5f} Test Acc: {:.2f}%\".format(test_loss, 100 * test_acc))\n",
+ " \n",
+ "save_checkpoint({'epoch': epoch + 1,\n",
+ " 'model_state_dict': qat_model.state_dict(),\n",
+ " 'acc': test_acc,\n",
+ " 'opt_state_dict': opt.state_dict(),\n",
+ " 'state': state},\n",
+ " ckpt_path=\"vgg16_qat_ckpt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a4dcaa2",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 7. Export to Torchscript\n",
+ "Export the model to Torch script. Trace the model and convert it into torchscript for deployment. To learn more about Torchscript, please refer to https://pytorch.org/docs/stable/jit.html. Setting `quant_nn.TensorQuantizer.use_fb_fake_quant = True` enables the QAT model to use `torch.fake_quantize_per_tensor_affine` and `torch.fake_quantize_per_channel_affine` operators instead of `tensor_quant` function to export quantization operators. In torchscript, they are represented as `aten::fake_quantize_per_tensor_affine` and `aten::fake_quantize_per_channel_affine`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "3d34f526",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "E1109 04:02:37.101168 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.102248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.107194 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.107625 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.115269 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.115740 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.117969 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.118358 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.126382 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.126834 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.128674 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.129518 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.135453 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.135936 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.137858 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.138366 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.145539 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.146053 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.147871 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.148353 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.154252 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.154685 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.156558 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.157159 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.163197 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.163676 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.165549 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.165991 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.173305 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.173926 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.176034 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.176697 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.182843 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.183426 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.185377 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.185962 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.191966 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.192424 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.194325 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.194817 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.201988 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.202665 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.204763 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.205461 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.211393 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.211987 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.213899 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.214450 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.220892 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.221533 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.223519 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.224037 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.233809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.234434 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.238212 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.239042 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.241022 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.241654 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.247820 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.248445 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.250366 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.250959 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.257248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.257854 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.259968 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.260660 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "W1109 04:02:37.268160 139704147265344 tensor_quantizer.py:280] Use Pytorch's native experimental fake quantization.\n",
+ "/opt/conda/lib/python3.8/site-packages/pytorch_quantization/nn/modules/tensor_quantizer.py:285: TracerWarning: Converting a tensor to a Python number might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+ " inputs, amax.item() / bound, 0,\n",
+ "/opt/conda/lib/python3.8/site-packages/pytorch_quantization/nn/modules/tensor_quantizer.py:291: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+ " quant_dim = list(amax.shape).index(list(amax_sequeeze.shape)[0])\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "E1109 04:02:37.329273 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.330212 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.332529 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.333365 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.339547 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.340248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.342257 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.342890 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.350619 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.351372 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.353470 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.354121 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.360090 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.360806 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.362803 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.363274 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.370369 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.371057 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.373071 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.373766 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.379890 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.380538 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.382532 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.383128 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.389077 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.389760 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.391815 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.392399 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.399809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.400472 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.402399 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.402939 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.408818 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.409424 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.411513 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.412097 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.418537 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.419128 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.421343 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.421946 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.429382 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.430156 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.432259 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.433079 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.439297 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.440027 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.442149 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.442826 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.449377 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.449968 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.452122 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.452754 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.462532 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.463295 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.466963 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.467725 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.469692 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.470336 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.476204 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.476738 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.478809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.479375 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.485666 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.486219 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.488416 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.488986 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n"
+ ]
+ }
+ ],
+ "source": [
+ "quant_nn.TensorQuantizer.use_fb_fake_quant = True\n",
+ "with torch.no_grad():\n",
+ " data = iter(testing_dataloader)\n",
+ " images, _ = data.next()\n",
+ " jit_model = torch.jit.trace(qat_model, images.to(\"cuda\"))\n",
+ " torch.jit.save(jit_model, \"trained_vgg16_qat.jit.pt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7341418a",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 8. Inference using Torch-TensorRT\n",
+ "In this phase, we run the exported torchscript graph of VGG QAT using Torch-TensorRT. Torch-TensorRT is a Pytorch-TensorRT compiler which converts Torchscript graphs into TensorRT. TensorRT 8.0 supports inference of quantization aware trained models and introduces new APIs; `QuantizeLayer` and `DequantizeLayer`. We can observe the entire VGG QAT graph quantization nodes from the debug log of Torch-TensorRT. To enable debug logging, you can set `torch_tensorrt.logging.set_reportable_log_level(torch_tensorrt.logging.Level.Debug)`. For example, `QuantConv2d` layer from `pytorch_quantization` toolkit is represented as follows in Torchscript\n",
+ "```\n",
+ "%quant_input : Tensor = aten::fake_quantize_per_tensor_affine(%x, %636, %637, %638, %639)\n",
+ "%quant_weight : Tensor = aten::fake_quantize_per_channel_affine(%394, %640, %641, %637, %638, %639)\n",
+ "%input.2 : Tensor = aten::_convolution(%quant_input, %quant_weight, %395, %687, %688, %689, %643, %690, %642, %643, %643, %644, %644)\n",
+ "```\n",
+ "`aten::fake_quantize_per_*_affine` is converted into `QuantizeLayer` + `DequantizeLayer` in Torch-TensorRT internally. Please refer to quantization op converters in Torch-TensorRT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "aa7495e0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING: [Torch-TensorRT] - Cannot infer input type from calcuations in graph for input x.2. Assuming it is Float32. If not, specify input type explicity\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT TorchScript Conversion Context] - Detected invalid timing cache, setup a local cache instead\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "VGG QAT accuracy using TensorRT: 82.97%\n"
+ ]
+ }
+ ],
+ "source": [
+ "qat_model = torch.jit.load(\"trained_vgg16_qat.jit.pt\").eval()\n",
+ "\n",
+ "compile_spec = {\"inputs\": [torch_tensorrt.Input([16, 3, 32, 32])],\n",
+ " \"enabled_precisions\": torch.int8,\n",
+ " }\n",
+ "trt_mod = torch_tensorrt.compile(qat_model, **compile_spec)\n",
+ "\n",
+ "test_loss, test_acc = test(trt_mod, testing_dataloader, crit, 0)\n",
+ "print(\"VGG QAT accuracy using TensorRT: {:.2f}%\".format(100 * test_acc))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9df5a90e",
+ "metadata": {},
+ "source": [
+ "### Performance benchmarking"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "9eb2cd2d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "import numpy as np\n",
+ "\n",
+ "import torch.backends.cudnn as cudnn\n",
+ "cudnn.benchmark = True\n",
+ "\n",
+ "# Helper function to benchmark the model\n",
+ "def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=1000):\n",
+ " input_data = torch.randn(input_shape)\n",
+ " input_data = input_data.to(\"cuda\")\n",
+ " if dtype=='fp16':\n",
+ " input_data = input_data.half()\n",
+ " \n",
+ " print(\"Warm up ...\")\n",
+ " with torch.no_grad():\n",
+ " for _ in range(nwarmup):\n",
+ " features = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " print(\"Start timing ...\")\n",
+ " timings = []\n",
+ " with torch.no_grad():\n",
+ " for i in range(1, nruns+1):\n",
+ " start_time = time.time()\n",
+ " output = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " end_time = time.time()\n",
+ " timings.append(end_time - start_time)\n",
+ " if i%100==0:\n",
+ " print('Iteration %d/%d, avg batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))\n",
+ "\n",
+ " print(\"Input shape:\", input_data.size())\n",
+ " print(\"Output shape:\", output.shape)\n",
+ " print('Average batch time: %.2f ms'%(np.mean(timings)*1000))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "5c2514ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, avg batch time 4.83 ms\n",
+ "Iteration 200/1000, avg batch time 4.83 ms\n",
+ "Iteration 300/1000, avg batch time 4.83 ms\n",
+ "Iteration 400/1000, avg batch time 4.83 ms\n",
+ "Iteration 500/1000, avg batch time 4.83 ms\n",
+ "Iteration 600/1000, avg batch time 4.83 ms\n",
+ "Iteration 700/1000, avg batch time 4.83 ms\n",
+ "Iteration 800/1000, avg batch time 4.83 ms\n",
+ "Iteration 900/1000, avg batch time 4.83 ms\n",
+ "Iteration 1000/1000, avg batch time 4.83 ms\n",
+ "Input shape: torch.Size([16, 3, 32, 32])\n",
+ "Output shape: torch.Size([16, 10])\n",
+ "Average batch time: 4.83 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(jit_model, input_shape=(16, 3, 32, 32))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "c5378ed6",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, avg batch time 1.87 ms\n",
+ "Iteration 200/1000, avg batch time 1.84 ms\n",
+ "Iteration 300/1000, avg batch time 1.85 ms\n",
+ "Iteration 400/1000, avg batch time 1.83 ms\n",
+ "Iteration 500/1000, avg batch time 1.82 ms\n",
+ "Iteration 600/1000, avg batch time 1.81 ms\n",
+ "Iteration 700/1000, avg batch time 1.81 ms\n",
+ "Iteration 800/1000, avg batch time 1.80 ms\n",
+ "Iteration 900/1000, avg batch time 1.80 ms\n",
+ "Iteration 1000/1000, avg batch time 1.79 ms\n",
+ "Input shape: torch.Size([16, 3, 32, 32])\n",
+ "Output shape: torch.Size([16, 10])\n",
+ "Average batch time: 1.79 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(trt_mod, input_shape=(16, 3, 32, 32))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6a5ec1c",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 9. References\n",
+ "* Very Deep Convolution Networks for large scale Image Recognition\n",
+ "* Achieving FP32 Accuracy for INT8 Inference Using Quantization Aware Training with NVIDIA TensorRT\n",
+ "* QAT workflow for VGG16\n",
+ "* Deploying VGG QAT model in C++ using Torch-TensorRT\n",
+ "* Pytorch-quantization toolkit from NVIDIA\n",
+ "* Pytorch quantization toolkit userguide\n",
+ "* Quantization basics"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/v1.1.1/_sources/_cpp_api/class_view_hierarchy.rst.txt b/docs/v1.1.1/_sources/_cpp_api/class_view_hierarchy.rst.txt
new file mode 100644
index 0000000000..a75671077c
--- /dev/null
+++ b/docs/v1.1.1/_sources/_cpp_api/class_view_hierarchy.rst.txt
@@ -0,0 +1,18 @@
+
+Class Hierarchy
+---------------
+
+
+.. raw:: html
+
+ \n",
+ "\n",
+ "# Torch-TensorRT Getting Started - CitriNet"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "[Citrinet](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/models.html#citrinet) is an acoustic model used for the speech to text recognition task. It is a version of [QuartzNet](https://arxiv.org/pdf/1910.10261.pdf) that extends [ContextNet](https://arxiv.org/pdf/2005.03191.pdf), utilizing subword encoding (via Word Piece tokenization) and Squeeze-and-Excitation(SE) mechanism and are therefore smaller than QuartzNet models.\n",
+ "\n",
+ "CitriNet models take in audio segments and transcribe them to letter, byte pair, or word piece sequences. \n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for optimizing a pretrained CitriNet model with Torch-TensorRT, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [Download Citrinet model](#2)\n",
+ "1. [Create Torch-TensorRT modules](#3)\n",
+ "1. [Benchmark Torch-TensorRT models](#4)\n",
+ "1. [Conclusion](#5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "Follow the steps in [README](README.md) to prepare a Docker container, within which you can run this notebook. \n",
+ "This notebook assumes that you are within a Jupyter environment in a docker container with Torch-TensorRT installed, such as an NGC monthly release of `nvcr.io/nvidia/pytorch:\n",
+ "\n",
+ "# Torch-TensorRT Getting Started - EfficientNet-B0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained EfficientNet network, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [EfficientNet Overview](#2)\n",
+ "1. [Running the model without optimizations](#3)\n",
+ "1. [Accelerating with Torch-TensorRT](#4)\n",
+ "1. [Conclusion](#5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting timm==0.4.12\n",
+ " Downloading timm-0.4.12-py3-none-any.whl (376 kB)\n",
+ "\u001b[K |████████████████████████████████| 376 kB 11.9 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: torch>=1.4 in /opt/conda/lib/python3.8/site-packages (from timm==0.4.12) (1.11.0a0+bfe5ad2)\n",
+ "Requirement already satisfied: torchvision in /opt/conda/lib/python3.8/site-packages (from timm==0.4.12) (0.12.0a0)\n",
+ "Requirement already satisfied: typing_extensions in /opt/conda/lib/python3.8/site-packages (from torch>=1.4->timm==0.4.12) (4.0.1)\n",
+ "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /opt/conda/lib/python3.8/site-packages (from torchvision->timm==0.4.12) (8.2.0)\n",
+ "Requirement already satisfied: numpy in /opt/conda/lib/python3.8/site-packages (from torchvision->timm==0.4.12) (1.22.0)\n",
+ "Installing collected packages: timm\n",
+ "Successfully installed timm-0.4.12\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
+ "Fri Feb 4 21:29:36 2022 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 NVIDIA GeForce ... On | 00000000:65:00.0 Off | N/A |\n",
+ "| 30% 28C P8 11W / 350W | 0MiB / 24576MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=============================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------+\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install timm==0.4.12\n",
+ "!nvidia-smi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "NVIDIA's NGC provides PyTorch Docker Container which contains PyTorch and Torch-TensorRT. We can make use of [latest pytorch](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch) container to run this notebook.\n",
+ "\n",
+ "Otherwise, you can follow the steps in `notebooks/README` to prepare a Docker container yourself, within which you can run this demo notebook."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. EfficientNet Overview\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called `timm`, which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet.\n",
+ "\n",
+ "### Model Description\n",
+ "\n",
+ "This model is based on the [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946) paper.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Running the model without optimizations\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called `timm`, which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "import torch_tensorrt\n",
+ "import timm\n",
+ "import time\n",
+ "import numpy as np\n",
+ "import torch.backends.cudnn as cudnn\n",
+ "from timm.data import resolve_data_config\n",
+ "from timm.data.transforms_factory import create_transform\n",
+ "import json \n",
+ "\n",
+ "efficientnet_b0_model = timm.create_model('efficientnet_b0',pretrained=True)\n",
+ "model = efficientnet_b0_model.eval().to(\"cuda\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With our model loaded, let's proceed to downloading some images!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "--2022-02-04 21:30:07-- https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\n",
+ "Resolving d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)... 18.65.227.127, 18.65.227.37, 18.65.227.99, ...\n",
+ "Connecting to d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)|18.65.227.127|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 24112 (24K) [image/jpeg]\n",
+ "Saving to: ‘./data/img0.JPG’\n",
+ "\n",
+ "./data/img0.JPG 100%[===================>] 23.55K --.-KB/s in 0.004s \n",
+ "\n",
+ "2022-02-04 21:30:07 (6.40 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]\n",
+ "\n",
+ "--2022-02-04 21:30:07-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\n",
+ "Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117\n",
+ "Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 452718 (442K) [image/jpeg]\n",
+ "Saving to: ‘./data/img1.JPG’\n",
+ "\n",
+ "./data/img1.JPG 100%[===================>] 442.11K --.-KB/s in 0.06s \n",
+ "\n",
+ "2022-02-04 21:30:07 (6.83 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]\n",
+ "\n",
+ "--2022-02-04 21:30:08-- https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\n",
+ "Resolving www.artis.nl (www.artis.nl)... 94.75.225.20\n",
+ "Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 361413 (353K) [image/jpeg]\n",
+ "Saving to: ‘./data/img2.JPG’\n",
+ "\n",
+ "./data/img2.JPG 100%[===================>] 352.94K 246KB/s in 1.4s \n",
+ "\n",
+ "2022-02-04 21:30:10 (246 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]\n",
+ "\n",
+ "--2022-02-04 21:30:10-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\n",
+ "Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.18.202.107, 104.18.201.107, 2606:4700::6812:ca6b, ...\n",
+ "Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.202.107|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 90994 (89K) [image/jpeg]\n",
+ "Saving to: ‘./data/img3.JPG’\n",
+ "\n",
+ "./data/img3.JPG 100%[===================>] 88.86K --.-KB/s in 0.006s \n",
+ "\n",
+ "2022-02-04 21:30:10 (14.4 MB/s) - ‘./data/img3.JPG’ saved [90994/90994]\n",
+ "\n",
+ "--2022-02-04 21:30:11-- https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\n",
+ "Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.216.133.45\n",
+ "Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.216.133.45|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 35363 (35K) [application/octet-stream]\n",
+ "Saving to: ‘./data/imagenet_class_index.json’\n",
+ "\n",
+ "./data/imagenet_cla 100%[===================>] 34.53K --.-KB/s in 0.07s \n",
+ "\n",
+ "2022-02-04 21:30:11 (474 KB/s) - ‘./data/imagenet_class_index.json’ saved [35363/35363]\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "!mkdir -p ./data\n",
+ "!wget -O ./data/img0.JPG \"https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\"\n",
+ "!wget -O ./data/img1.JPG \"https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\"\n",
+ "!wget -O ./data/img2.JPG \"https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\"\n",
+ "!wget -O ./data/img3.JPG \"https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\"\n",
+ "\n",
+ "!wget -O ./data/imagenet_class_index.json \"https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "All pre-trained models expect input images normalized in the same way,\n",
+ "i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.\n",
+ "The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`\n",
+ "and `std = [0.229, 0.224, 0.225]`.\n",
+ "\n",
+ "Here's a sample execution."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "\n",
+ "\n",
+ "# Masked Language Modeling (MLM) with Hugging Face BERT Transformer"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "83f47edb",
+ "metadata": {},
+ "source": [
+ "## Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained BERT transformer from Hugging Face, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Contents\n",
+ "1. [Requirements](#1)\n",
+ "2. [BERT Overview](#2)\n",
+ "3. [Creating TorchScript modules](#3)\n",
+ "4. [Compiling with Torch-TensorRT](#4)\n",
+ "5. [Benchmarking](#5)\n",
+ "6. [Conclusion](#6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "596fa151",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "NVIDIA's NGC provides a PyTorch Docker Container which contains PyTorch and Torch-TensorRT. Starting with version `22.05-py3`, we can make use of [latest pytorch](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch) container to run this notebook.\n",
+ "\n",
+ "Otherwise, you can follow the steps in `notebooks/README` to prepare a Docker container yourself, within which you can run this demo notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "58e687d1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Requirement already satisfied: transformers in /opt/conda/lib/python3.8/site-packages (4.18.0)\n",
+ "Requirement already satisfied: tqdm>=4.27 in /opt/conda/lib/python3.8/site-packages (from transformers) (4.63.0)\n",
+ "Requirement already satisfied: regex!=2019.12.17 in /opt/conda/lib/python3.8/site-packages (from transformers) (2022.3.15)\n",
+ "Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from transformers) (0.5.1)\n",
+ "Requirement already satisfied: tokenizers!=0.11.3,<0.13,>=0.11.1 in /opt/conda/lib/python3.8/site-packages (from transformers) (0.12.1)\n",
+ "Requirement already satisfied: numpy>=1.17 in /opt/conda/lib/python3.8/site-packages (from transformers) (1.22.3)\n",
+ "Requirement already satisfied: sacremoses in /opt/conda/lib/python3.8/site-packages (from transformers) (0.0.49)\n",
+ "Requirement already satisfied: requests in /opt/conda/lib/python3.8/site-packages (from transformers) (2.27.1)\n",
+ "Requirement already satisfied: pyyaml>=5.1 in /opt/conda/lib/python3.8/site-packages (from transformers) (6.0)\n",
+ "Requirement already satisfied: filelock in /opt/conda/lib/python3.8/site-packages (from transformers) (3.6.0)\n",
+ "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.8/site-packages (from transformers) (21.3)\n",
+ "Requirement already satisfied: typing-extensions>=3.7.4.3 in /opt/conda/lib/python3.8/site-packages (from huggingface-hub<1.0,>=0.1.0->transformers) (4.1.1)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging>=20.0->transformers) (3.0.7)\n",
+ "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (1.26.8)\n",
+ "Requirement already satisfied: charset-normalizer~=2.0.0 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (2.0.12)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (2021.10.8)\n",
+ "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.8/site-packages (from requests->transformers) (3.3)\n",
+ "Requirement already satisfied: six in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (1.16.0)\n",
+ "Requirement already satisfied: click in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (8.0.4)\n",
+ "Requirement already satisfied: joblib in /opt/conda/lib/python3.8/site-packages (from sacremoses->transformers) (1.1.0)\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install transformers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "1104c4f1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from transformers import BertTokenizer, BertForMaskedLM\n",
+ "import torch\n",
+ "import timeit\n",
+ "import numpy as np\n",
+ "import torch_tensorrt\n",
+ "import torch.backends.cudnn as cudnn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "acf67a5e",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. BERT Overview\n",
+ "\n",
+ "Transformers comprise a class of deep learning algorithms employing self-attention; broadly speaking, the models learn large matrices of numbers, each element of which denotes how important one component of input data is to another. Since their introduction in 2017, transformers have enjoyed widespread adoption, particularly in natural language processing, but also in computer vision problems. This is largely because they are easier to parallelize than the sequence models which attention mechanisms were originally designed to augment. \n",
+ "\n",
+ "Hugging Face is a company that maintains a huge respository of pre-trained transformer models. The company also provides tools for integrating those models into PyTorch code and running inference with them. \n",
+ "\n",
+ "One of the most popular transformer models is BERT (Bidirectional Encoder Representations from Transformers). First developed at Google and released in 2018, it has become the backbone of Google's search engine and a standard benchmark for NLP experiments. BERT was originally trained for next sentence prediction and masked language modeling (MLM), which aims to predict hidden words in sentences. In this notebook, we will use Hugging Face's `bert-base-uncased` model (BERT's smallest and simplest form, which does not employ text capitalization) for MLM."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "19e711c0",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Creating TorchScript modules "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81d4c6f6",
+ "metadata": {},
+ "source": [
+ "First, create a pretrained BERT tokenizer from the `bert-base-uncased` model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "c7c8721e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "enc = BertTokenizer.from_pretrained('bert-base-uncased')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b7c1c679",
+ "metadata": {},
+ "source": [
+ "Create dummy inputs to generate a traced TorchScript model later"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "c3827087",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "batch_size = 4\n",
+ "\n",
+ "batched_indexed_tokens = [[101, 64]*64]*batch_size\n",
+ "batched_segment_ids = [[0, 1]*64]*batch_size\n",
+ "batched_attention_masks = [[1, 1]*64]*batch_size\n",
+ "\n",
+ "tokens_tensor = torch.tensor(batched_indexed_tokens)\n",
+ "segments_tensor = torch.tensor(batched_segment_ids)\n",
+ "attention_masks_tensor = torch.tensor(batched_attention_masks)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e31b27f",
+ "metadata": {},
+ "source": [
+ "Obtain a BERT masked language model from Hugging Face in the (scripted) TorchScript, then use the dummy inputs to trace it"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "a3cd5a35",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForMaskedLM: ['cls.seq_relationship.bias', 'cls.seq_relationship.weight']\n",
+ "- This IS expected if you are initializing BertForMaskedLM from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+ "- This IS NOT expected if you are initializing BertForMaskedLM from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
+ ]
+ }
+ ],
+ "source": [
+ "mlm_model_ts = BertForMaskedLM.from_pretrained('bert-base-uncased', torchscript=True)\n",
+ "traced_mlm_model = torch.jit.trace(mlm_model_ts, [tokens_tensor, segments_tensor, attention_masks_tensor])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d8d2217a",
+ "metadata": {},
+ "source": [
+ "Define 4 masked sentences, with 1 word in each sentence hidden from the model. Fluent English speakers will probably be able to guess the masked words, but just in case, they are `'capital'`, `'language'`, `'innings'`, and `'mathematics'`.\n",
+ "\n",
+ "Also create a list containing the position of the masked word within each sentence. Given Python's 0-based indexing convention, the numbers are each higher by 1 than might be expected. This is because the token at index 0 in each sentence is a beginning-of-sentence token, denoted `[CLS]` when entered explicitly. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "4d1af982",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "masked_sentences = ['Paris is the [MASK] of France.', \n",
+ " 'The primary [MASK] of the United States is English.', \n",
+ " 'A baseball game consists of at least nine [MASK].', \n",
+ " 'Topology is a branch of [MASK] concerned with the properties of geometric objects that remain unchanged under continuous transformations.']\n",
+ "pos_masks = [4, 3, 9, 6]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4d89b4c8",
+ "metadata": {},
+ "source": [
+ "Pass the masked sentences into the (scripted) TorchScript MLM model and verify that the unmasked sentences yield the expected results. \n",
+ "\n",
+ "Because the sentences are of different lengths, we must specify the `padding` argument in calling our encoder/tokenizer. There are several possible padding strategies, but we'll use `'max_length'` padding with `max_length=128`. Later, when we compile an optimized version of the model with Torch-TensorRT, the optimized model will expect inputs of length 128, hence our choice of padding strategy and length here. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d2d7546b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Paris is the capital of France.\n",
+ "The primary language of the United States is English.\n",
+ "A baseball game consists of at least nine innings.\n",
+ "Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.\n"
+ ]
+ }
+ ],
+ "source": [
+ "encoded_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)\n",
+ "outputs = mlm_model_ts(**encoded_inputs)\n",
+ "most_likely_token_ids = [torch.argmax(outputs[0][i, pos, :]) for i, pos in enumerate(pos_masks)]\n",
+ "unmasked_tokens = enc.decode(most_likely_token_ids).split(' ')\n",
+ "unmasked_sentences = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens)]\n",
+ "for sentence in unmasked_sentences:\n",
+ " print(sentence)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b0b423ff",
+ "metadata": {},
+ "source": [
+ "Pass the masked sentences into the traced MLM model and verify that the unmasked sentences yield the expected results. \n",
+ "\n",
+ "Note the difference in how the `encoded_inputs` are passed into the model in the following cell compared to the previous one. If you examine `encoded_inputs`, you'll find that it's a dictionary with 3 keys, `'input_ids'`, `'token_type_ids'`, and `'attention_mask'`, each with a PyTorch tensor as an associated value. The traced model will accept `**encoded_inputs` as an input, but the Torch-TensorRT-optimized model (to be defined later) will not. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "683a4a73",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Paris is the capital of France.\n",
+ "The primary language of the United States is English.\n",
+ "A baseball game consists of at least nine innings.\n",
+ "Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.\n"
+ ]
+ }
+ ],
+ "source": [
+ "encoded_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)\n",
+ "outputs = traced_mlm_model(encoded_inputs['input_ids'], encoded_inputs['token_type_ids'], encoded_inputs['attention_mask'])\n",
+ "most_likely_token_ids = [torch.argmax(outputs[0][i, pos, :]) for i, pos in enumerate(pos_masks)]\n",
+ "unmasked_tokens = enc.decode(most_likely_token_ids).split(' ')\n",
+ "unmasked_sentences = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens)]\n",
+ "for sentence in unmasked_sentences:\n",
+ " print(sentence)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a31b545",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 4. Compiling with Torch-TensorRT"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "413d8b4f",
+ "metadata": {},
+ "source": [
+ "Change the logging level to avoid long printouts"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "42862893",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "new_level = torch_tensorrt.logging.Level.Error\n",
+ "torch_tensorrt.logging.set_reportable_log_level(new_level)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "121d6d59",
+ "metadata": {},
+ "source": [
+ "Compile the model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "eab90150",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trt_model = torch_tensorrt.compile(traced_mlm_model, \n",
+ " inputs= [torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # input_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # token_type_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32)], # attention_mask\n",
+ " enabled_precisions= {torch.float32}, # Run with 32-bit precision\n",
+ " workspace_size=2000000000,\n",
+ " truncate_long_and_double=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a96751ce",
+ "metadata": {},
+ "source": [
+ "Pass the masked sentences into the compiled model and verify that the unmasked sentences yield the expected results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "097ea381",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Paris is the capital of France.\n",
+ "The primary language of the United States is English.\n",
+ "A baseball game consists of at least nine innings.\n",
+ "Topology is a branch of mathematics concerned with the properties of geometric objects that remain unchanged under continuous transformations.\n"
+ ]
+ }
+ ],
+ "source": [
+ "enc_inputs = enc(masked_sentences, return_tensors='pt', padding='max_length', max_length=128)\n",
+ "enc_inputs = {k: v.type(torch.int32).cuda() for k, v in enc_inputs.items()}\n",
+ "output_trt = trt_model(enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "most_likely_token_ids_trt = [torch.argmax(output_trt[i, pos, :]) for i, pos in enumerate(pos_masks)] \n",
+ "unmasked_tokens_trt = enc.decode(most_likely_token_ids_trt).split(' ')\n",
+ "unmasked_sentences_trt = [masked_sentences[i].replace('[MASK]', token) for i, token in enumerate(unmasked_tokens_trt)]\n",
+ "for sentence in unmasked_sentences_trt:\n",
+ " print(sentence)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a398271d",
+ "metadata": {},
+ "source": [
+ "Compile the model again, this time with 16-bit precision"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "a063dee2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "trt_model_fp16 = torch_tensorrt.compile(traced_mlm_model, \n",
+ " inputs= [torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # input_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32), # token_type_ids\n",
+ " torch_tensorrt.Input(shape=[batch_size, 128], dtype=torch.int32)], # attention_mask\n",
+ " enabled_precisions= {torch.half}, # Run with 16-bit precision\n",
+ " workspace_size=2000000000,\n",
+ " truncate_long_and_double=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a926334a",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 5. Benchmarking\n",
+ "\n",
+ "In developing this notebook, we conducted our benchmarking on a single NVIDIA A100 GPU. Your results may differ from those shown, particularly on a different GPU."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "976c6fb9",
+ "metadata": {},
+ "source": [
+ "This function passes the inputs into the model and runs inference `num_loops` times, then returns a list of length containing the amount of time in seconds that each instance of inference took."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "b72a091e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def timeGraph(model, input_tensor1, input_tensor2, input_tensor3, num_loops=50):\n",
+ " print(\"Warm up ...\")\n",
+ " with torch.no_grad():\n",
+ " for _ in range(20):\n",
+ " features = model(input_tensor1, input_tensor2, input_tensor3)\n",
+ "\n",
+ " torch.cuda.synchronize()\n",
+ "\n",
+ " print(\"Start timing ...\")\n",
+ " timings = []\n",
+ " with torch.no_grad():\n",
+ " for i in range(num_loops):\n",
+ " start_time = timeit.default_timer()\n",
+ " features = model(input_tensor1, input_tensor2, input_tensor3)\n",
+ " torch.cuda.synchronize()\n",
+ " end_time = timeit.default_timer()\n",
+ " timings.append(end_time - start_time)\n",
+ " # print(\"Iteration {}: {:.6f} s\".format(i, end_time - start_time))\n",
+ "\n",
+ " return timings"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0b44dcf8",
+ "metadata": {},
+ "source": [
+ "This function prints the number of input batches the model is able to process each second and summary statistics of the model's latency."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "2ef71ab7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def printStats(graphName, timings, batch_size):\n",
+ " times = np.array(timings)\n",
+ " steps = len(times)\n",
+ " speeds = batch_size / times\n",
+ " time_mean = np.mean(times)\n",
+ " time_med = np.median(times)\n",
+ " time_99th = np.percentile(times, 99)\n",
+ " time_std = np.std(times, ddof=0)\n",
+ " speed_mean = np.mean(speeds)\n",
+ " speed_med = np.median(speeds)\n",
+ "\n",
+ " msg = (\"\\n%s =================================\\n\"\n",
+ " \"batch size=%d, num iterations=%d\\n\"\n",
+ " \" Median text batches/second: %.1f, mean: %.1f\\n\"\n",
+ " \" Median latency: %.6f, mean: %.6f, 99th_p: %.6f, std_dev: %.6f\\n\"\n",
+ " ) % (graphName,\n",
+ " batch_size, steps,\n",
+ " speed_med, speed_mean,\n",
+ " time_med, time_mean, time_99th, time_std)\n",
+ " print(msg)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "afe97b9b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cudnn.benchmark = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eba98b24",
+ "metadata": {},
+ "source": [
+ "Benchmark the (scripted) TorchScript model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "bab5fa8f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 599.1, mean: 597.6\n",
+ " Median latency: 0.006677, mean: 0.006693, 99th_p: 0.006943, std_dev: 0.000059\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(mlm_model_ts.cuda(), enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc79c452",
+ "metadata": {},
+ "source": [
+ "Benchmark the traced model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "5c0bd8e9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 951.2, mean: 951.0\n",
+ " Median latency: 0.004205, mean: 0.004206, 99th_p: 0.004256, std_dev: 0.000015\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(traced_mlm_model.cuda(), enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "41db22a1",
+ "metadata": {},
+ "source": [
+ "Benchmark the compiled FP32 model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "ade7b508",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 1216.9, mean: 1216.4\n",
+ " Median latency: 0.003287, mean: 0.003289, 99th_p: 0.003317, std_dev: 0.000007\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(trt_model, enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "57b696de",
+ "metadata": {},
+ "source": [
+ "Benchmark the compiled FP16 model on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "f61b83fd",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "\n",
+ "BERT =================================\n",
+ "batch size=4, num iterations=50\n",
+ " Median text batches/second: 1776.7, mean: 1771.1\n",
+ " Median latency: 0.002251, mean: 0.002259, 99th_p: 0.002305, std_dev: 0.000015\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "timings = timeGraph(trt_model_fp16, enc_inputs['input_ids'], enc_inputs['token_type_ids'], enc_inputs['attention_mask'])\n",
+ "\n",
+ "printStats(\"BERT\", timings, batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "43f67ba3",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 6. Conclusion\n",
+ "\n",
+ "In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT for Masked Language Modeling with Hugging Face's `bert-base-uncased` transformer and testing the performance impact of the optimization. With Torch-TensorRT on an NVIDIA A100 GPU, we observe the speedups indicated below. These acceleration numbers will vary from GPU to GPU (as well as implementation to implementation based on the ops used) and we encorage you to try out latest generation of Data center compute cards for maximum acceleration.\n",
+ "\n",
+ "Scripted (GPU): 1.0x\n",
+ "Traced (GPU): 1.62x\n",
+ "Torch-TensorRT (FP32): 2.14x\n",
+ "Torch-TensorRT (FP16): 3.15x\n",
+ "\n",
+ "### What's next\n",
+ "Now it's time to try Torch-TensorRT on your own model. If you run into any issues, you can fill them at https://github.com/NVIDIA/Torch-TensorRT. Your involvement will help future development of Torch-TensorRT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ebd152d",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/v1.1.1/_sources/_notebooks/Resnet50-example.ipynb.txt b/docs/v1.1.1/_sources/_notebooks/Resnet50-example.ipynb.txt
new file mode 100644
index 0000000000..f020662c73
--- /dev/null
+++ b/docs/v1.1.1/_sources/_notebooks/Resnet50-example.ipynb.txt
@@ -0,0 +1,925 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Copyright 2019 NVIDIA Corporation. All Rights Reserved.\n",
+ "#\n",
+ "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+ "# you may not use this file except in compliance with the License.\n",
+ "# You may obtain a copy of the License at\n",
+ "#\n",
+ "# http://www.apache.org/licenses/LICENSE-2.0\n",
+ "#\n",
+ "# Unless required by applicable law or agreed to in writing, software\n",
+ "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+ "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+ "# See the License for the specific language governing permissions and\n",
+ "# limitations under the License.\n",
+ "# =============================================================================="
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "# Torch-TensorRT Getting Started - ResNet 50"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained ResNet-50 network, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [ResNet-50 Overview](#2)\n",
+ "1. [Running the model without optimizations](#3)\n",
+ "1. [Accelerating with Torch-TensorRT](#4)\n",
+ "1. [Conclusion](#5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Tue Feb 8 19:16:53 2022 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 NVIDIA GeForce ... On | 00000000:65:00.0 Off | N/A |\n",
+ "| 30% 29C P8 15W / 350W | 0MiB / 24576MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=============================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------+\n",
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting ipywidgets\n",
+ " Downloading ipywidgets-7.6.5-py2.py3-none-any.whl (121 kB)\n",
+ "\u001b[K |████████████████████████████████| 121 kB 5.3 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.7.0)\n",
+ "Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)\n",
+ "Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (7.31.0)\n",
+ "Collecting jupyterlab-widgets>=1.0.0\n",
+ " Downloading jupyterlab_widgets-1.0.2-py3-none-any.whl (243 kB)\n",
+ "\u001b[K |████████████████████████████████| 243 kB 2.6 MB/s eta 0:00:01\n",
+ "\u001b[?25hCollecting widgetsnbextension~=3.5.0\n",
+ " Downloading widgetsnbextension-3.5.2-py2.py3-none-any.whl (1.6 MB)\n",
+ "\u001b[K |████████████████████████████████| 1.6 MB 3.5 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)\n",
+ "Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)\n",
+ "Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)\n",
+ "Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)\n",
+ "Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)\n",
+ "Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)\n",
+ "Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)\n",
+ "Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)\n",
+ "Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.0)\n",
+ "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.24)\n",
+ "Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)\n",
+ "Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.1)\n",
+ "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)\n",
+ "Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)\n",
+ "Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)\n",
+ "Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)\n",
+ "Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)\n",
+ "Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)\n",
+ "Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)\n",
+ "Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)\n",
+ "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)\n",
+ "Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)\n",
+ "Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)\n",
+ "Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.5.0->ipywidgets) (6.4.1)\n",
+ "Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.8.0)\n",
+ "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.3)\n",
+ "Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3.0)\n",
+ "Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.13.0)\n",
+ "Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.12.1)\n",
+ "Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (6.4.0)\n",
+ "Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.2.0)\n",
+ "Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.15.0)\n",
+ "Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.21)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.0.1)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.1.2)\n",
+ "Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.7.1)\n",
+ "Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (4.1.0)\n",
+ "Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.10)\n",
+ "Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.0)\n",
+ "Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.5.0)\n",
+ "Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.8.4)\n",
+ "Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3)\n",
+ "Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.1)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.6)\n",
+ "Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets\n",
+ "Successfully installed ipywidgets-7.6.5 jupyterlab-widgets-1.0.2 widgetsnbextension-3.5.2\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "!nvidia-smi\n",
+ "!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "NVIDIA's NGC provides PyTorch Docker Container which contains PyTorch and Torch-TensorRT. We can make use of [latest pytorch](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch) container to run this notebook.\n",
+ "\n",
+ "Otherwise, you can follow the steps in `notebooks/README` to prepare a Docker container yourself, within which you can run this demo notebook."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. ResNet-50 Overview\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called the PyTorch Hub, which is a source for high quality implementations of common models. We can get our ResNet-50 model from there pretrained on ImageNet.\n",
+ "\n",
+ "### Model Description\n",
+ "\n",
+ "This ResNet-50 model is based on the [Deep Residual Learning for Image Recognition](https://arxiv.org/pdf/1512.03385.pdf) paper, which describes ResNet as “a method for detecting objects in images using a single deep neural network\". The input size is fixed to 32x32.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Running the model without optimizations\n",
+ "\n",
+ "\n",
+ "PyTorch has a model repository called `timm`, which is a source for high quality implementations of computer vision models. We can get our EfficientNet model from there pretrained on ImageNet."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Downloading: \"https://github.com/pytorch/vision/archive/v0.10.0.zip\" to /root/.cache/torch/hub/v0.10.0.zip\n",
+ "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a7036a6122874340b14aaef7b8319260",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " 0%| | 0.00/97.8M [00:00] 23.55K --.-KB/s in 0.002s \n",
+ "\n",
+ "2022-02-08 19:17:19 (14.6 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]\n",
+ "\n",
+ "--2022-02-08 19:17:19-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\n",
+ "Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117\n",
+ "Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 452718 (442K) [image/jpeg]\n",
+ "Saving to: ‘./data/img1.JPG’\n",
+ "\n",
+ "./data/img1.JPG 100%[===================>] 442.11K 2.40MB/s in 0.2s \n",
+ "\n",
+ "2022-02-08 19:17:19 (2.40 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]\n",
+ "\n",
+ "--2022-02-08 19:17:20-- https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\n",
+ "Resolving www.artis.nl (www.artis.nl)... 94.75.225.20\n",
+ "Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 361413 (353K) [image/jpeg]\n",
+ "Saving to: ‘./data/img2.JPG’\n",
+ "\n",
+ "./data/img2.JPG 100%[===================>] 352.94K 366KB/s in 1.0s \n",
+ "\n",
+ "2022-02-08 19:17:24 (366 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]\n",
+ "\n",
+ "--2022-02-08 19:17:24-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\n",
+ "Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.18.201.107, 104.18.202.107, 2606:4700::6812:ca6b, ...\n",
+ "Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.201.107|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 94328 (92K) [image/jpeg]\n",
+ "Saving to: ‘./data/img3.JPG’\n",
+ "\n",
+ "./data/img3.JPG 100%[===================>] 92.12K --.-KB/s in 0.005s \n",
+ "\n",
+ "2022-02-08 19:17:25 (16.8 MB/s) - ‘./data/img3.JPG’ saved [94328/94328]\n",
+ "\n",
+ "--2022-02-08 19:17:25-- https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\n",
+ "Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.217.41.222\n",
+ "Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.217.41.222|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 35363 (35K) [application/octet-stream]\n",
+ "Saving to: ‘./data/imagenet_class_index.json’\n",
+ "\n",
+ "./data/imagenet_cla 100%[===================>] 34.53K --.-KB/s in 0.07s \n",
+ "\n",
+ "2022-02-08 19:17:26 (481 KB/s) - ‘./data/imagenet_class_index.json’ saved [35363/35363]\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "!mkdir -p ./data\n",
+ "!wget -O ./data/img0.JPG \"https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\"\n",
+ "!wget -O ./data/img1.JPG \"https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\"\n",
+ "!wget -O ./data/img2.JPG \"https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\"\n",
+ "!wget -O ./data/img3.JPG \"https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\"\n",
+ "\n",
+ "!wget -O ./data/imagenet_class_index.json \"https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "All pre-trained models expect input images normalized in the same way,\n",
+ "i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.\n",
+ "The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`\n",
+ "and `std = [0.229, 0.224, 0.225]`.\n",
+ "\n",
+ "Here's a sample execution."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "\n",
+ "\n",
+ "# Torch-TensorRT Getting Started - LeNet"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a simple LeNet network. \n",
+ "\n",
+ "## Content\n",
+ "1. [Requirements](#1)\n",
+ "1. [Creating TorchScript modules](#2)\n",
+ "1. [Compiling with Torch-TensorRT](#3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "Follow the steps in `notebooks/README` to prepare a Docker container, within which you can run this notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting ipywidgets\n",
+ " Downloading ipywidgets-7.6.5-py2.py3-none-any.whl (121 kB)\n",
+ "\u001b[K |████████████████████████████████| 121 kB 12.7 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)\n",
+ "Collecting jupyterlab-widgets>=1.0.0\n",
+ " Downloading jupyterlab_widgets-1.0.2-py3-none-any.whl (243 kB)\n",
+ "\u001b[K |████████████████████████████████| 243 kB 115.0 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)\n",
+ "Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.7.0)\n",
+ "Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (7.31.0)\n",
+ "Collecting widgetsnbextension~=3.5.0\n",
+ " Downloading widgetsnbextension-3.5.2-py2.py3-none-any.whl (1.6 MB)\n",
+ "\u001b[K |████████████████████████████████| 1.6 MB 122.5 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)\n",
+ "Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)\n",
+ "Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)\n",
+ "Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)\n",
+ "Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)\n",
+ "Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)\n",
+ "Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)\n",
+ "Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)\n",
+ "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.24)\n",
+ "Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.0)\n",
+ "Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.1)\n",
+ "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)\n",
+ "Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)\n",
+ "Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)\n",
+ "Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)\n",
+ "Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)\n",
+ "Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)\n",
+ "Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)\n",
+ "Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)\n",
+ "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)\n",
+ "Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)\n",
+ "Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)\n",
+ "Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.5.0->ipywidgets) (6.4.1)\n",
+ "Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.12.1)\n",
+ "Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.13.0)\n",
+ "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.3)\n",
+ "Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3.0)\n",
+ "Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (6.4.0)\n",
+ "Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.8.0)\n",
+ "Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.2.0)\n",
+ "Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.15.0)\n",
+ "Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.21)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (2.0.1)\n",
+ "Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.0)\n",
+ "Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.7.1)\n",
+ "Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.1.2)\n",
+ "Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.10)\n",
+ "Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (4.1.0)\n",
+ "Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (1.5.0)\n",
+ "Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.8.4)\n",
+ "Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (0.5.1)\n",
+ "Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (21.3)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets) (3.0.6)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets\n",
+ "Successfully installed ipywidgets-7.6.5 jupyterlab-widgets-1.0.2 widgetsnbextension-3.5.2\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
+ "Thu Feb 10 22:01:27 2022 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 510.39.01 Driver Version: 510.39.01 CUDA Version: 11.6 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 NVIDIA GeForce ... On | 00000000:09:00.0 Off | N/A |\n",
+ "| 0% 42C P8 20W / 320W | 0MiB / 10240MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=============================================================================|\n",
+ "| No running processes found |\n",
+ "+-----------------------------------------------------------------------------+\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org\n",
+ "!nvidia-smi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2. Creating TorchScript modules\n",
+ "\n",
+ "Here we create two submodules for a feature extractor and a classifier and stitch them together in a single LeNet module. In this case this is overkill but modules give us granular control over our program including where we decide to optimize and where we don't. It is also the unit that the TorchScript compiler operates on. So you can decide to only convert/optimize the feature extractor and leave the classifier in standard PyTorch or you can convert the whole thing. When compiling your module to TorchScript, there are two paths: Tracing and Scripting. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch \n",
+ "from torch import nn\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class LeNetFeatExtractor(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(LeNetFeatExtractor, self).__init__()\n",
+ " self.conv1 = nn.Conv2d(1, 128, 3)\n",
+ " self.conv2 = nn.Conv2d(128, 16, 3)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
+ " x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
+ " return x\n",
+ "\n",
+ "class LeNetClassifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(LeNetClassifier, self).__init__()\n",
+ " self.fc1 = nn.Linear(16 * 6 * 6, 120)\n",
+ " self.fc2 = nn.Linear(120, 84)\n",
+ " self.fc3 = nn.Linear(84, 10)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = torch.flatten(x,1)\n",
+ " x = F.relu(self.fc1(x))\n",
+ " x = F.relu(self.fc2(x))\n",
+ " x = self.fc3(x)\n",
+ " return x\n",
+ "\n",
+ "class LeNet(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(LeNet, self).__init__()\n",
+ " self.feat = LeNetFeatExtractor()\n",
+ " self.classifer = LeNetClassifier()\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = self.feat(x)\n",
+ " x = self.classifer(x)\n",
+ " return x\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let us define a helper function to benchmark a model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "import numpy as np\n",
+ "\n",
+ "import torch.backends.cudnn as cudnn\n",
+ "cudnn.benchmark = True\n",
+ "\n",
+ "def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=1000):\n",
+ " input_data = torch.randn(input_shape)\n",
+ " input_data = input_data.to(\"cuda\")\n",
+ " if dtype=='fp16':\n",
+ " input_data = input_data.half()\n",
+ " \n",
+ " print(\"Warm up ...\")\n",
+ " with torch.no_grad():\n",
+ " for _ in range(nwarmup):\n",
+ " features = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " print(\"Start timing ...\")\n",
+ " timings = []\n",
+ " with torch.no_grad():\n",
+ " for i in range(1, nruns+1):\n",
+ " start_time = time.time()\n",
+ " features = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " end_time = time.time()\n",
+ " timings.append(end_time - start_time)\n",
+ " if i%100==0:\n",
+ " print('Iteration %d/%d, ave batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))\n",
+ "\n",
+ " print(\"Input shape:\", input_data.size())\n",
+ " print(\"Output features size:\", features.size())\n",
+ " \n",
+ " print('Average batch time: %.2f ms'%(np.mean(timings)*1000))\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### PyTorch model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "LeNet(\n",
+ " (feat): LeNetFeatExtractor(\n",
+ " (conv1): Conv2d(1, 128, kernel_size=(3, 3), stride=(1, 1))\n",
+ " (conv2): Conv2d(128, 16, kernel_size=(3, 3), stride=(1, 1))\n",
+ " )\n",
+ " (classifer): LeNetClassifier(\n",
+ " (fc1): Linear(in_features=576, out_features=120, bias=True)\n",
+ " (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
+ " (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model = LeNet()\n",
+ "model.to(\"cuda\").eval()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 5.56 ms\n",
+ "Iteration 200/1000, ave batch time 5.56 ms\n",
+ "Iteration 300/1000, ave batch time 5.56 ms\n",
+ "Iteration 400/1000, ave batch time 5.56 ms\n",
+ "Iteration 500/1000, ave batch time 5.56 ms\n",
+ "Iteration 600/1000, ave batch time 5.56 ms\n",
+ "Iteration 700/1000, ave batch time 5.56 ms\n",
+ "Iteration 800/1000, ave batch time 5.56 ms\n",
+ "Iteration 900/1000, ave batch time 5.56 ms\n",
+ "Iteration 1000/1000, ave batch time 5.56 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 5.56 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "When compiling your module to TorchScript, there are two paths: Tracing and Scripting. \n",
+ " \n",
+ "### Tracing\n",
+ "\n",
+ "Tracing follows the path of execution when the module is called and records what happens. This recording is what the TorchScript IR will describe. To trace an instance of our LeNet module, we can call torch.jit.trace with an example input. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "LeNet(\n",
+ " original_name=LeNet\n",
+ " (feat): LeNetFeatExtractor(\n",
+ " original_name=LeNetFeatExtractor\n",
+ " (conv1): Conv2d(original_name=Conv2d)\n",
+ " (conv2): Conv2d(original_name=Conv2d)\n",
+ " )\n",
+ " (classifer): LeNetClassifier(\n",
+ " original_name=LeNetClassifier\n",
+ " (fc1): Linear(original_name=Linear)\n",
+ " (fc2): Linear(original_name=Linear)\n",
+ " (fc3): Linear(original_name=Linear)\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "traced_model = torch.jit.trace(model, torch.empty([1,1,32,32]).to(\"cuda\"))\n",
+ "traced_model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 5.56 ms\n",
+ "Iteration 200/1000, ave batch time 5.56 ms\n",
+ "Iteration 300/1000, ave batch time 5.56 ms\n",
+ "Iteration 400/1000, ave batch time 5.56 ms\n",
+ "Iteration 500/1000, ave batch time 5.56 ms\n",
+ "Iteration 600/1000, ave batch time 5.56 ms\n",
+ "Iteration 700/1000, ave batch time 5.56 ms\n",
+ "Iteration 800/1000, ave batch time 5.56 ms\n",
+ "Iteration 900/1000, ave batch time 5.56 ms\n",
+ "Iteration 1000/1000, ave batch time 5.56 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 5.56 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(traced_model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Scripting\n",
+ "\n",
+ "Scripting actually inspects your code with a compiler and generates an equivalent TorchScript program. The difference is that since tracing simply follows the execution of your module, it cannot pick up control flow for instance, it will only follow the code path that a particular input triggers. By working from the Python code, the compiler can include these components. We can run the script compiler on our LeNet module by calling torch.jit.script.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = LeNet().to(\"cuda\").eval()\n",
+ "script_model = torch.jit.script(model)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "RecursiveScriptModule(\n",
+ " original_name=LeNet\n",
+ " (feat): RecursiveScriptModule(\n",
+ " original_name=LeNetFeatExtractor\n",
+ " (conv1): RecursiveScriptModule(original_name=Conv2d)\n",
+ " (conv2): RecursiveScriptModule(original_name=Conv2d)\n",
+ " )\n",
+ " (classifer): RecursiveScriptModule(\n",
+ " original_name=LeNetClassifier\n",
+ " (fc1): RecursiveScriptModule(original_name=Linear)\n",
+ " (fc2): RecursiveScriptModule(original_name=Linear)\n",
+ " (fc3): RecursiveScriptModule(original_name=Linear)\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "script_model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 5.56 ms\n",
+ "Iteration 200/1000, ave batch time 5.56 ms\n",
+ "Iteration 300/1000, ave batch time 5.56 ms\n",
+ "Iteration 400/1000, ave batch time 5.56 ms\n",
+ "Iteration 500/1000, ave batch time 5.56 ms\n",
+ "Iteration 600/1000, ave batch time 5.56 ms\n",
+ "Iteration 700/1000, ave batch time 5.56 ms\n",
+ "Iteration 800/1000, ave batch time 5.56 ms\n",
+ "Iteration 900/1000, ave batch time 5.56 ms\n",
+ "Iteration 1000/1000, ave batch time 5.56 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 5.56 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(script_model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Compiling with Torch-TensorRT"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### TorchScript traced model\n",
+ "\n",
+ "First, we compile the TorchScript traced model with Torch-TensorRT. Notice the performance impact."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float\n",
+ "The compiler is going to use the user setting Float16\n",
+ "This conflict may cause an error at runtime due to partial compilation being enabled and therefore\n",
+ "compatibility with PyTorch's data type convention is required.\n",
+ "If you do indeed see errors at runtime either:\n",
+ "- Remove the dtype spec for x.1\n",
+ "- Disable partial compilation by setting require_full_compilation to True\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT TorchScript Conversion Context] - Max value of this profile is not valid\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch_tensorrt\n",
+ "\n",
+ "# We use a batch-size of 1024, and half precision\n",
+ "trt_ts_module = torch_tensorrt.compile(traced_model, inputs=[torch_tensorrt.Input(\n",
+ " min_shape=[1024, 1, 32, 32],\n",
+ " opt_shape=[1024, 1, 33, 33],\n",
+ " max_shape=[1024, 1, 34, 34],\n",
+ " dtype=torch.half\n",
+ " )], \n",
+ " enabled_precisions = {torch.half})\n",
+ "\n",
+ "input_data = torch.randn((1024, 1, 32, 32))\n",
+ "input_data = input_data.half().to(\"cuda\")\n",
+ "\n",
+ "input_data = input_data.half()\n",
+ "result = trt_ts_module(input_data)\n",
+ "torch.jit.save(trt_ts_module, \"trt_ts_module.ts\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 1.41 ms\n",
+ "Iteration 200/1000, ave batch time 1.40 ms\n",
+ "Iteration 300/1000, ave batch time 1.40 ms\n",
+ "Iteration 400/1000, ave batch time 1.39 ms\n",
+ "Iteration 500/1000, ave batch time 1.40 ms\n",
+ "Iteration 600/1000, ave batch time 1.40 ms\n",
+ "Iteration 700/1000, ave batch time 1.40 ms\n",
+ "Iteration 800/1000, ave batch time 1.40 ms\n",
+ "Iteration 900/1000, ave batch time 1.40 ms\n",
+ "Iteration 1000/1000, ave batch time 1.40 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 1.40 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(trt_ts_module, input_shape=(1024, 1, 32, 32), dtype=\"fp16\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### TorchScript script model\n",
+ "\n",
+ "Next, we compile the TorchScript script model with Torch-TensorRT. Notice the performance impact."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING: [Torch-TensorRT] - For input x.1, found user specified input dtype as Float16, however when inspecting the graph, the input type expected was inferred to be Float\n",
+ "The compiler is going to use the user setting Float16\n",
+ "This conflict may cause an error at runtime due to partial compilation being enabled and therefore\n",
+ "compatibility with PyTorch's data type convention is required.\n",
+ "If you do indeed see errors at runtime either:\n",
+ "- Remove the dtype spec for x.1\n",
+ "- Disable partial compilation by setting require_full_compilation to True\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT TorchScript Conversion Context] - Max value of this profile is not valid\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch_tensorrt\n",
+ "\n",
+ "trt_script_module = torch_tensorrt.compile(script_model, inputs = [torch_tensorrt.Input(\n",
+ " min_shape=[1024, 1, 32, 32],\n",
+ " opt_shape=[1024, 1, 33, 33],\n",
+ " max_shape=[1024, 1, 34, 34],\n",
+ " dtype=torch.half\n",
+ " )],\n",
+ " enabled_precisions={torch.half})\n",
+ "\n",
+ "input_data = torch.randn((1024, 1, 32, 32))\n",
+ "input_data = input_data.half().to(\"cuda\")\n",
+ "\n",
+ "input_data = input_data.half()\n",
+ "result = trt_script_module(input_data)\n",
+ "torch.jit.save(trt_script_module, \"trt_script_module.ts\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, ave batch time 1.43 ms\n",
+ "Iteration 200/1000, ave batch time 1.41 ms\n",
+ "Iteration 300/1000, ave batch time 1.40 ms\n",
+ "Iteration 400/1000, ave batch time 1.42 ms\n",
+ "Iteration 500/1000, ave batch time 1.42 ms\n",
+ "Iteration 600/1000, ave batch time 1.41 ms\n",
+ "Iteration 700/1000, ave batch time 1.41 ms\n",
+ "Iteration 800/1000, ave batch time 1.40 ms\n",
+ "Iteration 900/1000, ave batch time 1.40 ms\n",
+ "Iteration 1000/1000, ave batch time 1.40 ms\n",
+ "Input shape: torch.Size([1024, 1, 32, 32])\n",
+ "Output features size: torch.Size([1024, 10])\n",
+ "Average batch time: 1.40 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(trt_script_module, input_shape=(1024, 1, 32, 32), dtype=\"fp16\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Conclusion\n",
+ "\n",
+ "In this notebook, we have walked through the complete process of compiling TorchScript models with Torch-TensorRT and test the performance impact of the optimization.\n",
+ "\n",
+ "### What's next\n",
+ "Now it's time to try Torch-TensorRT on your own model. Fill out issues at https://github.com/NVIDIA/Torch-TensorRT. Your involvement will help future development of Torch-TensorRT.\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/v1.1.1/_sources/_notebooks/ssd-object-detection-demo.ipynb.txt b/docs/v1.1.1/_sources/_notebooks/ssd-object-detection-demo.ipynb.txt
new file mode 100644
index 0000000000..f2a0bd8063
--- /dev/null
+++ b/docs/v1.1.1/_sources/_notebooks/ssd-object-detection-demo.ipynb.txt
@@ -0,0 +1,943 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Copyright 2020 NVIDIA Corporation. All Rights Reserved.\n",
+ "#\n",
+ "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+ "# you may not use this file except in compliance with the License.\n",
+ "# You may obtain a copy of the License at\n",
+ "#\n",
+ "# http://www.apache.org/licenses/LICENSE-2.0\n",
+ "#\n",
+ "# Unless required by applicable law or agreed to in writing, software\n",
+ "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+ "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+ "# See the License for the specific language governing permissions and\n",
+ "# limitations under the License.\n",
+ "# =============================================================================="
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "# Object Detection with Torch-TensorRT (SSD)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "## Overview\n",
+ "\n",
+ "In the practice of developing machine learning models, there are few tools as approachable as PyTorch for developing and experimenting in designing machine learning models. The power of PyTorch comes from its deep integration into Python, its flexibility and its approach to automatic differentiation and execution (eager execution). However, when moving from research into production, the requirements change and we may no longer want that deep Python integration and we want optimization to get the best performance we can on our deployment platform. In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable. TorchScript uses PyTorch's JIT compiler to transform your normal PyTorch code which gets interpreted by the Python interpreter to an intermediate representation (IR) which can have optimizations run on it and at runtime can get interpreted by the PyTorch JIT interpreter. For PyTorch this has opened up a whole new world of possibilities, including deployment in other languages like C++. It also introduces a structured graph based format that we can use to do down to the kernel level optimization of models for inference.\n",
+ "\n",
+ "When deploying on NVIDIA GPUs TensorRT, NVIDIA's Deep Learning Optimization SDK and Runtime is able to take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family be it an A100, TITAN V, Jetson Xavier or NVIDIA's Deep Learning Accelerator. TensorRT performs a couple sets of optimizations to achieve this. TensorRT fuses layers and tensors in the model graph, it then uses a large kernel library to select implementations that perform best on the target GPU. TensorRT also has strong support for reduced operating precision execution which allows users to leverage the Tensor Cores on Volta and newer GPUs as well as reducing memory and computation footprints on device.\n",
+ "\n",
+ "Torch-TensorRT is a compiler that uses TensorRT to optimize TorchScript code, compiling standard TorchScript modules into ones that internally run with TensorRT optimizations. This enables you to continue to remain in the PyTorch ecosystem, using all the great features PyTorch has such as module composability, its flexible tensor implementation, data loaders and more. Torch-TensorRT is available to use with both PyTorch and LibTorch."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Learning objectives\n",
+ "\n",
+ "This notebook demonstrates the steps for compiling a TorchScript module with Torch-TensorRT on a pretrained SSD network, and running it to test the speedup obtained.\n",
+ "\n",
+ "## Contents\n",
+ "1. [Requirements](#1)\n",
+ "2. [SSD Overview](#2)\n",
+ "3. [Creating TorchScript modules](#3)\n",
+ "4. [Compiling with Torch-TensorRT](#4)\n",
+ "5. [Running Inference](#5)\n",
+ "6. [Measuring Speedup](#6)\n",
+ "7. [Conclusion](#7)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "\n",
+ "## 1. Requirements\n",
+ "\n",
+ "Follow the steps in `notebooks/README` to prepare a Docker container, within which you can run this demo notebook.\n",
+ "\n",
+ "In addition to that, run the following cell to obtain additional libraries specific to this demo."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting scikit-image==0.19.1\n",
+ " Downloading scikit_image-0.19.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.8 MB)\n",
+ "\u001b[K |████████████████████████████████| 13.8 MB 8.8 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: networkx>=2.2 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (2.6.3)\n",
+ "Collecting tifffile>=2019.7.26\n",
+ " Downloading tifffile-2022.3.16-py3-none-any.whl (179 kB)\n",
+ "\u001b[K |████████████████████████████████| 179 kB 110.1 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (21.3)\n",
+ "Requirement already satisfied: scipy>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (1.6.3)\n",
+ "Requirement already satisfied: numpy>=1.17.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (1.22.2)\n",
+ "Collecting imageio>=2.4.1\n",
+ " Downloading imageio-2.16.1-py3-none-any.whl (3.3 MB)\n",
+ "\u001b[K |████████████████████████████████| 3.3 MB 42.3 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: pillow!=7.1.0,!=7.1.1,!=8.3.0,>=6.1.0 in /opt/conda/lib/python3.8/site-packages (from scikit-image==0.19.1) (9.0.0)\n",
+ "Collecting PyWavelets>=1.1.1\n",
+ " Downloading PyWavelets-1.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.9 MB)\n",
+ "\u001b[K |████████████████████████████████| 6.9 MB 61.3 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging>=20.0->scikit-image==0.19.1) (3.0.7)\n",
+ "Installing collected packages: tifffile, PyWavelets, imageio, scikit-image\n",
+ "Successfully installed PyWavelets-1.3.0 imageio-2.16.1 scikit-image-0.19.1 tifffile-2022.3.16\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n",
+ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n",
+ "Collecting ipywidgets\n",
+ " Downloading ipywidgets-7.7.0-py2.py3-none-any.whl (123 kB)\n",
+ "\u001b[K |████████████████████████████████| 123 kB 12.1 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (6.9.0)\n",
+ "Collecting jupyterlab-widgets>=1.0.0\n",
+ " Downloading jupyterlab_widgets-1.1.0-py3-none-any.whl (245 kB)\n",
+ "\u001b[K |████████████████████████████████| 245 kB 60.6 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: nbformat>=4.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.3)\n",
+ "Requirement already satisfied: ipython-genutils~=0.2.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: ipython>=4.0.0 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (8.0.1)\n",
+ "Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.8/site-packages (from ipywidgets) (5.1.1)\n",
+ "Collecting widgetsnbextension~=3.6.0\n",
+ " Downloading widgetsnbextension-3.6.0-py2.py3-none-any.whl (1.6 MB)\n",
+ "\u001b[K |████████████████████████████████| 1.6 MB 35.2 MB/s eta 0:00:01\n",
+ "\u001b[?25hRequirement already satisfied: nest-asyncio in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.4)\n",
+ "Requirement already satisfied: jupyter-client<8.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (7.1.2)\n",
+ "Requirement already satisfied: tornado<7.0,>=4.2 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (6.1)\n",
+ "Requirement already satisfied: matplotlib-inline<0.2.0,>=0.1.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (0.1.3)\n",
+ "Requirement already satisfied: debugpy<2.0,>=1.0.0 in /opt/conda/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets) (1.5.1)\n",
+ "Requirement already satisfied: stack-data in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.1.4)\n",
+ "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (3.0.26)\n",
+ "Requirement already satisfied: pickleshare in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.7.5)\n",
+ "Requirement already satisfied: pygments in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (2.11.2)\n",
+ "Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (4.8.0)\n",
+ "Requirement already satisfied: decorator in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (5.1.1)\n",
+ "Requirement already satisfied: backcall in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.2.0)\n",
+ "Requirement already satisfied: black in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (22.1.0)\n",
+ "Requirement already satisfied: setuptools>=18.5 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (59.5.0)\n",
+ "Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.8/site-packages (from ipython>=4.0.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0->ipywidgets) (0.8.3)\n",
+ "Requirement already satisfied: entrypoints in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (0.3)\n",
+ "Requirement already satisfied: pyzmq>=13 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (22.3.0)\n",
+ "Requirement already satisfied: jupyter-core>=4.6.0 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (4.9.1)\n",
+ "Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.8/site-packages (from jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (2.8.2)\n",
+ "Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /opt/conda/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets) (4.4.0)\n",
+ "Requirement already satisfied: attrs>=17.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (21.4.0)\n",
+ "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (0.18.1)\n",
+ "Requirement already satisfied: importlib-resources>=1.4.0 in /opt/conda/lib/python3.8/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (5.4.0)\n",
+ "Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.8/site-packages (from importlib-resources>=1.4.0->jsonschema!=2.5.0,>=2.4->nbformat>=4.2.0->ipywidgets) (3.7.0)\n",
+ "Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.8/site-packages (from pexpect>4.3->ipython>=4.0.0->ipywidgets) (0.7.0)\n",
+ "Requirement already satisfied: wcwidth in /opt/conda/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0->ipywidgets) (0.2.5)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.8/site-packages (from python-dateutil>=2.1->jupyter-client<8.0->ipykernel>=4.5.1->ipywidgets) (1.16.0)\n",
+ "Requirement already satisfied: notebook>=4.4.1 in /opt/conda/lib/python3.8/site-packages (from widgetsnbextension~=3.6.0->ipywidgets) (6.4.1)\n",
+ "Requirement already satisfied: terminado>=0.8.3 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.13.1)\n",
+ "Requirement already satisfied: Send2Trash>=1.5.0 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.8.0)\n",
+ "Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.13.1)\n",
+ "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (3.0.3)\n",
+ "Requirement already satisfied: nbconvert in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (6.4.2)\n",
+ "Requirement already satisfied: argon2-cffi in /opt/conda/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.3.0)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: argon2-cffi-bindings in /opt/conda/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.2.0)\n",
+ "Requirement already satisfied: cffi>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.15.0)\n",
+ "Requirement already satisfied: pycparser in /opt/conda/lib/python3.8/site-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.21)\n",
+ "Requirement already satisfied: pathspec>=0.9.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (0.9.0)\n",
+ "Requirement already satisfied: tomli>=1.1.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (2.0.1)\n",
+ "Requirement already satisfied: mypy-extensions>=0.4.3 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (0.4.3)\n",
+ "Requirement already satisfied: click>=8.0.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (8.0.3)\n",
+ "Requirement already satisfied: platformdirs>=2 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (2.4.1)\n",
+ "Requirement already satisfied: typing-extensions>=3.10.0.0 in /opt/conda/lib/python3.8/site-packages (from black->ipython>=4.0.0->ipywidgets) (4.0.1)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (2.0.1)\n",
+ "Requirement already satisfied: defusedxml in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.7.1)\n",
+ "Requirement already satisfied: mistune<2,>=0.8.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.8.4)\n",
+ "Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.11)\n",
+ "Requirement already satisfied: testpath in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.0)\n",
+ "Requirement already satisfied: jupyterlab-pygments in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.1.2)\n",
+ "Requirement already satisfied: bleach in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (4.1.0)\n",
+ "Requirement already satisfied: pandocfilters>=1.4.1 in /opt/conda/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (1.5.0)\n",
+ "Requirement already satisfied: webencodings in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (0.5.1)\n",
+ "Requirement already satisfied: packaging in /opt/conda/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (21.3)\n",
+ "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.8/site-packages (from packaging->bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets) (3.0.7)\n",
+ "Requirement already satisfied: executing in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.8.2)\n",
+ "Requirement already satisfied: pure-eval in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (0.2.2)\n",
+ "Requirement already satisfied: asttokens in /opt/conda/lib/python3.8/site-packages (from stack-data->ipython>=4.0.0->ipywidgets) (2.0.5)\n",
+ "Installing collected packages: widgetsnbextension, jupyterlab-widgets, ipywidgets\n",
+ "Successfully installed ipywidgets-7.7.0 jupyterlab-widgets-1.1.0 widgetsnbextension-3.6.0\n",
+ "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install scikit-image==0.19.1\n",
+ "!pip install ipywidgets --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host=files.pythonhosted.org"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "\n",
+ "## 2. SSD\n",
+ "\n",
+ "### Single Shot MultiBox Detector model for object detection\n",
+ "\n",
+ "_ | _\n",
+ "- | -\n",
+ " | "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "PyTorch has a model repository called the PyTorch Hub, which is a source for high quality implementations of common models. We can get our SSD model pretrained on [COCO](https://cocodataset.org/#home) from there.\n",
+ "\n",
+ "### Model Description\n",
+ "\n",
+ "This SSD300 model is based on the\n",
+ "[SSD: Single Shot MultiBox Detector](https://arxiv.org/abs/1512.02325) paper, which\n",
+ "describes SSD as “a method for detecting objects in images using a single deep neural network\".\n",
+ "The input size is fixed to 300x300.\n",
+ "\n",
+ "The main difference between this model and the one described in the paper is in the backbone.\n",
+ "Specifically, the VGG model is obsolete and is replaced by the ResNet-50 model.\n",
+ "\n",
+ "From the\n",
+ "[Speed/accuracy trade-offs for modern convolutional object detectors](https://arxiv.org/abs/1611.10012)\n",
+ "paper, the following enhancements were made to the backbone:\n",
+ "* The conv5_x, avgpool, fc and softmax layers were removed from the original classification model.\n",
+ "* All strides in conv4_x are set to 1x1.\n",
+ "\n",
+ "The backbone is followed by 5 additional convolutional layers.\n",
+ "In addition to the convolutional layers, we attached 6 detection heads:\n",
+ "* The first detection head is attached to the last conv4_x layer.\n",
+ "* The other five detection heads are attached to the corresponding 5 additional layers.\n",
+ "\n",
+ "Detector heads are similar to the ones referenced in the paper, however,\n",
+ "they are enhanced by additional BatchNorm layers after each convolution.\n",
+ "\n",
+ "More information about this SSD model is available at Nvidia's \"DeepLearningExamples\" Github [here](https://github.com/NVIDIA/DeepLearningExamples/tree/master/PyTorch/Detection/SSD)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "torch.hub._validate_not_a_forked_repo=lambda a,b,c: True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Downloading: \"https://github.com/NVIDIA/DeepLearningExamples/archive/torchhub.zip\" to /root/.cache/torch/hub/torchhub.zip\n",
+ "/root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub/PyTorch/Classification/ConvNets/image_classification/models/efficientnet.py:17: UserWarning: pytorch_quantization module not found, quantization will not be available\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "['nvidia_convnets_processing_utils',\n",
+ " 'nvidia_efficientnet',\n",
+ " 'nvidia_efficientnet_b0',\n",
+ " 'nvidia_efficientnet_b4',\n",
+ " 'nvidia_efficientnet_widese_b0',\n",
+ " 'nvidia_efficientnet_widese_b4',\n",
+ " 'nvidia_resneXt',\n",
+ " 'nvidia_resnet50',\n",
+ " 'nvidia_resnext101_32x4d',\n",
+ " 'nvidia_se_resnext101_32x4d',\n",
+ " 'nvidia_ssd',\n",
+ " 'nvidia_ssd_processing_utils',\n",
+ " 'nvidia_tacotron2',\n",
+ " 'nvidia_tts_utils',\n",
+ " 'nvidia_waveglow']"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# List of available models in PyTorch Hub from Nvidia/DeepLearningExamples\n",
+ "torch.hub.list('NVIDIA/DeepLearningExamples:torchhub')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Using cache found in /root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub\n",
+ "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1c7cf3e1635d4a2b9c8731b7fc9ce724",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ " 0%| | 0.00/97.8M [00:0040%) in a more comprehensive format.\n",
+ "results_per_input = utils.decode_results(detections_batch)\n",
+ "best_results_per_input = [utils.pick_best(results, 0.40) for results in results_per_input]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Visualize results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from matplotlib import pyplot as plt\n",
+ "import matplotlib.patches as patches\n",
+ "\n",
+ "# The utility plots the images and predicted bounding boxes (with confidence scores).\n",
+ "def plot_results(best_results):\n",
+ " for image_idx in range(len(best_results)):\n",
+ " fig, ax = plt.subplots(1)\n",
+ " # Show original, denormalized image...\n",
+ " image = inputs[image_idx] / 2 + 0.5\n",
+ " ax.imshow(image)\n",
+ " # ...with detections\n",
+ " bboxes, classes, confidences = best_results[image_idx]\n",
+ " for idx in range(len(bboxes)):\n",
+ " left, bot, right, top = bboxes[idx]\n",
+ " x, y, w, h = [val * 300 for val in [left, bot, right - left, top - bot]]\n",
+ " rect = patches.Rectangle((x, y), w, h, linewidth=1, edgecolor='r', facecolor='none')\n",
+ " ax.add_patch(rect)\n",
+ " ax.text(x, y, \"{} {:.0f}%\".format(classes_to_labels[classes[idx] - 1], confidences[idx]*100), bbox=dict(facecolor='white', alpha=0.5))\n",
+ " plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a5afc49",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3. Training a baseline VGG16 model\n",
+ "We train VGG16 on CIFAR10 dataset. Define training and testing datasets and dataloaders. This will download the CIFAR 10 data in your `data` directory. Data preprocessing is performed using `torchvision` transforms. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "5d2c4c45",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Files already downloaded and verified\n",
+ "Files already downloaded and verified\n"
+ ]
+ }
+ ],
+ "source": [
+ "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
+ "\n",
+ "# ========== Define Training dataset and dataloaders =============#\n",
+ "training_dataset = datasets.CIFAR10(root='./data',\n",
+ " train=True,\n",
+ " download=True,\n",
+ " transform=transforms.Compose([\n",
+ " transforms.RandomCrop(32, padding=4),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
+ " ]))\n",
+ "\n",
+ "training_dataloader = torch.utils.data.DataLoader(training_dataset,\n",
+ " batch_size=32,\n",
+ " shuffle=True,\n",
+ " num_workers=2)\n",
+ "\n",
+ "# ========== Define Testing dataset and dataloaders =============#\n",
+ "testing_dataset = datasets.CIFAR10(root='./data',\n",
+ " train=False,\n",
+ " download=True,\n",
+ " transform=transforms.Compose([\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
+ " ]))\n",
+ "\n",
+ "testing_dataloader = torch.utils.data.DataLoader(testing_dataset,\n",
+ " batch_size=16,\n",
+ " shuffle=False,\n",
+ " num_workers=2)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "2bd092b3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def train(model, dataloader, crit, opt, epoch):\n",
+ "# global writer\n",
+ " model.train()\n",
+ " running_loss = 0.0\n",
+ " for batch, (data, labels) in enumerate(dataloader):\n",
+ " data, labels = data.cuda(), labels.cuda(non_blocking=True)\n",
+ " opt.zero_grad()\n",
+ " out = model(data)\n",
+ " loss = crit(out, labels)\n",
+ " loss.backward()\n",
+ " opt.step()\n",
+ "\n",
+ " running_loss += loss.item()\n",
+ " if batch % 500 == 499:\n",
+ " print(\"Batch: [%5d | %5d] loss: %.3f\" % (batch + 1, len(dataloader), running_loss / 100))\n",
+ " running_loss = 0.0\n",
+ " \n",
+ "def test(model, dataloader, crit, epoch):\n",
+ " global writer\n",
+ " global classes\n",
+ " total = 0\n",
+ " correct = 0\n",
+ " loss = 0.0\n",
+ " class_probs = []\n",
+ " class_preds = []\n",
+ " model.eval()\n",
+ " with torch.no_grad():\n",
+ " for data, labels in dataloader:\n",
+ " data, labels = data.cuda(), labels.cuda(non_blocking=True)\n",
+ " out = model(data)\n",
+ " loss += crit(out, labels)\n",
+ " preds = torch.max(out, 1)[1]\n",
+ " class_probs.append([F.softmax(i, dim=0) for i in out])\n",
+ " class_preds.append(preds)\n",
+ " total += labels.size(0)\n",
+ " correct += (preds == labels).sum().item()\n",
+ "\n",
+ " test_probs = torch.cat([torch.stack(batch) for batch in class_probs])\n",
+ " test_preds = torch.cat(class_preds)\n",
+ "\n",
+ " return loss / total, correct / total\n",
+ "\n",
+ "def save_checkpoint(state, ckpt_path=\"checkpoint.pth\"):\n",
+ " torch.save(state, ckpt_path)\n",
+ " print(\"Checkpoint saved\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c80a86cc",
+ "metadata": {},
+ "source": [
+ "*Define the VGG model that we are going to perfom QAT on.*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "8c564b8f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# CIFAR 10 has 10 classes\n",
+ "model = vgg16(num_classes=len(classes), init_weights=False)\n",
+ "model = model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "abc00452",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Declare Learning rate\n",
+ "lr = 0.1\n",
+ "state = {}\n",
+ "state[\"lr\"] = lr\n",
+ "\n",
+ "# Use cross entropy loss for classification and SGD optimizer\n",
+ "crit = nn.CrossEntropyLoss()\n",
+ "opt = optim.SGD(model.parameters(), lr=state[\"lr\"], momentum=0.9, weight_decay=1e-4)\n",
+ "\n",
+ "\n",
+ "# Adjust learning rate based on epoch number\n",
+ "def adjust_lr(optimizer, epoch):\n",
+ " global state\n",
+ " new_lr = lr * (0.5**(epoch // 12)) if state[\"lr\"] > 1e-7 else state[\"lr\"]\n",
+ " if new_lr != state[\"lr\"]:\n",
+ " state[\"lr\"] = new_lr\n",
+ " print(\"Updating learning rate: {}\".format(state[\"lr\"]))\n",
+ " for param_group in optimizer.param_groups:\n",
+ " param_group[\"lr\"] = state[\"lr\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "d80865a2",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: [ 1 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 13.288\n",
+ "Batch: [ 1000 | 1563] loss: 11.345\n",
+ "Batch: [ 1500 | 1563] loss: 11.008\n",
+ "Test Loss: 0.13388 Test Acc: 13.23%\n",
+ "Epoch: [ 2 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 10.742\n",
+ "Batch: [ 1000 | 1563] loss: 10.311\n",
+ "Batch: [ 1500 | 1563] loss: 10.141\n",
+ "Test Loss: 0.11888 Test Acc: 23.96%\n",
+ "Epoch: [ 3 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.877\n",
+ "Batch: [ 1000 | 1563] loss: 9.821\n",
+ "Batch: [ 1500 | 1563] loss: 9.818\n",
+ "Test Loss: 0.11879 Test Acc: 24.68%\n",
+ "Epoch: [ 4 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.677\n",
+ "Batch: [ 1000 | 1563] loss: 9.613\n",
+ "Batch: [ 1500 | 1563] loss: 9.504\n",
+ "Test Loss: 0.11499 Test Acc: 23.68%\n",
+ "Epoch: [ 5 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.560\n",
+ "Batch: [ 1000 | 1563] loss: 9.536\n",
+ "Batch: [ 1500 | 1563] loss: 9.309\n",
+ "Test Loss: 0.10990 Test Acc: 27.84%\n",
+ "Epoch: [ 6 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.254\n",
+ "Batch: [ 1000 | 1563] loss: 9.234\n",
+ "Batch: [ 1500 | 1563] loss: 9.188\n",
+ "Test Loss: 0.11594 Test Acc: 23.29%\n",
+ "Epoch: [ 7 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.141\n",
+ "Batch: [ 1000 | 1563] loss: 9.110\n",
+ "Batch: [ 1500 | 1563] loss: 9.013\n",
+ "Test Loss: 0.10732 Test Acc: 29.24%\n",
+ "Epoch: [ 8 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 9.120\n",
+ "Batch: [ 1000 | 1563] loss: 9.086\n",
+ "Batch: [ 1500 | 1563] loss: 8.948\n",
+ "Test Loss: 0.10732 Test Acc: 27.24%\n",
+ "Epoch: [ 9 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.941\n",
+ "Batch: [ 1000 | 1563] loss: 8.997\n",
+ "Batch: [ 1500 | 1563] loss: 9.028\n",
+ "Test Loss: 0.11299 Test Acc: 25.52%\n",
+ "Epoch: [ 10 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.927\n",
+ "Batch: [ 1000 | 1563] loss: 8.837\n",
+ "Batch: [ 1500 | 1563] loss: 8.860\n",
+ "Test Loss: 0.10130 Test Acc: 34.61%\n",
+ "Epoch: [ 11 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.953\n",
+ "Batch: [ 1000 | 1563] loss: 8.738\n",
+ "Batch: [ 1500 | 1563] loss: 8.724\n",
+ "Test Loss: 0.10018 Test Acc: 32.27%\n",
+ "Epoch: [ 12 / 25] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 8.721\n",
+ "Batch: [ 1000 | 1563] loss: 8.716\n",
+ "Batch: [ 1500 | 1563] loss: 8.701\n",
+ "Test Loss: 0.10070 Test Acc: 29.57%\n",
+ "Updating learning rate: 0.05\n",
+ "Epoch: [ 13 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 7.944\n",
+ "Batch: [ 1000 | 1563] loss: 7.649\n",
+ "Batch: [ 1500 | 1563] loss: 7.511\n",
+ "Test Loss: 0.08555 Test Acc: 44.62%\n",
+ "Epoch: [ 14 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 7.057\n",
+ "Batch: [ 1000 | 1563] loss: 6.944\n",
+ "Batch: [ 1500 | 1563] loss: 6.687\n",
+ "Test Loss: 0.08331 Test Acc: 52.27%\n",
+ "Epoch: [ 15 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 6.470\n",
+ "Batch: [ 1000 | 1563] loss: 6.439\n",
+ "Batch: [ 1500 | 1563] loss: 6.126\n",
+ "Test Loss: 0.07266 Test Acc: 58.02%\n",
+ "Epoch: [ 16 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 5.834\n",
+ "Batch: [ 1000 | 1563] loss: 5.801\n",
+ "Batch: [ 1500 | 1563] loss: 5.622\n",
+ "Test Loss: 0.06340 Test Acc: 65.17%\n",
+ "Epoch: [ 17 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 5.459\n",
+ "Batch: [ 1000 | 1563] loss: 5.442\n",
+ "Batch: [ 1500 | 1563] loss: 5.314\n",
+ "Test Loss: 0.05945 Test Acc: 67.22%\n",
+ "Epoch: [ 18 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 5.071\n",
+ "Batch: [ 1000 | 1563] loss: 5.145\n",
+ "Batch: [ 1500 | 1563] loss: 5.063\n",
+ "Test Loss: 0.06567 Test Acc: 64.46%\n",
+ "Epoch: [ 19 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.796\n",
+ "Batch: [ 1000 | 1563] loss: 4.781\n",
+ "Batch: [ 1500 | 1563] loss: 4.732\n",
+ "Test Loss: 0.05374 Test Acc: 71.87%\n",
+ "Epoch: [ 20 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.568\n",
+ "Batch: [ 1000 | 1563] loss: 4.564\n",
+ "Batch: [ 1500 | 1563] loss: 4.484\n",
+ "Test Loss: 0.05311 Test Acc: 71.12%\n",
+ "Epoch: [ 21 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.385\n",
+ "Batch: [ 1000 | 1563] loss: 4.302\n",
+ "Batch: [ 1500 | 1563] loss: 4.285\n",
+ "Test Loss: 0.05080 Test Acc: 74.29%\n",
+ "Epoch: [ 22 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 4.069\n",
+ "Batch: [ 1000 | 1563] loss: 4.105\n",
+ "Batch: [ 1500 | 1563] loss: 4.096\n",
+ "Test Loss: 0.04807 Test Acc: 75.20%\n",
+ "Epoch: [ 23 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 3.959\n",
+ "Batch: [ 1000 | 1563] loss: 3.898\n",
+ "Batch: [ 1500 | 1563] loss: 3.916\n",
+ "Test Loss: 0.04743 Test Acc: 75.81%\n",
+ "Epoch: [ 24 / 25] LR: 0.050000\n",
+ "Batch: [ 500 | 1563] loss: 3.738\n",
+ "Batch: [ 1000 | 1563] loss: 3.847\n",
+ "Batch: [ 1500 | 1563] loss: 3.797\n",
+ "Test Loss: 0.04609 Test Acc: 76.42%\n",
+ "Updating learning rate: 0.025\n",
+ "Epoch: [ 25 / 25] LR: 0.025000\n",
+ "Batch: [ 500 | 1563] loss: 2.952\n",
+ "Batch: [ 1000 | 1563] loss: 2.906\n",
+ "Batch: [ 1500 | 1563] loss: 2.735\n",
+ "Test Loss: 0.03466 Test Acc: 82.00%\n",
+ "Checkpoint saved\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Train the model for 25 epochs to get ~80% accuracy.\n",
+ "num_epochs=25\n",
+ "for epoch in range(num_epochs):\n",
+ " adjust_lr(opt, epoch)\n",
+ " print('Epoch: [%5d / %5d] LR: %f' % (epoch + 1, num_epochs, state[\"lr\"]))\n",
+ "\n",
+ " train(model, training_dataloader, crit, opt, epoch)\n",
+ " test_loss, test_acc = test(model, testing_dataloader, crit, epoch)\n",
+ "\n",
+ " print(\"Test Loss: {:.5f} Test Acc: {:.2f}%\".format(test_loss, 100 * test_acc))\n",
+ " \n",
+ "save_checkpoint({'epoch': epoch + 1,\n",
+ " 'model_state_dict': model.state_dict(),\n",
+ " 'acc': test_acc,\n",
+ " 'opt_state_dict': opt.state_dict(),\n",
+ " 'state': state},\n",
+ " ckpt_path=\"vgg16_base_ckpt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e1044537",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 4. Apply Quantization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c33b7f4e",
+ "metadata": {},
+ "source": [
+ "`quant_modules.initialize()` will ensure quantized version of modules will be called instead of original modules. For example, when you define a model with convolution, linear, pooling layers, `QuantConv2d`, `QuantLinear` and `QuantPooling` will be called. `QuantConv2d` basically wraps quantizer nodes around inputs and weights of regular `Conv2d`. Please refer to all the quantized modules in pytorch-quantization toolkit for more information. A `QuantConv2d` is represented in `pytorch-quantization` toolkit as follows.\n",
+ "\n",
+ "```\n",
+ "def forward(self, input):\n",
+ " # the actual quantization happens in the next level of the class hierarchy\n",
+ " quant_input, quant_weight = self._quant(input)\n",
+ "\n",
+ " if self.padding_mode == 'circular':\n",
+ " expanded_padding = ((self.padding[1] + 1) // 2, self.padding[1] // 2,\n",
+ " (self.padding[0] + 1) // 2, self.padding[0] // 2)\n",
+ " output = F.conv2d(F.pad(quant_input, expanded_padding, mode='circular'),\n",
+ " quant_weight, self.bias, self.stride,\n",
+ " _pair(0), self.dilation, self.groups)\n",
+ " else:\n",
+ " output = F.conv2d(quant_input, quant_weight, self.bias, self.stride, self.padding, self.dilation,\n",
+ " self.groups)\n",
+ "\n",
+ " return output\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "985dc59e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "quant_modules.initialize()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "164ce8cb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# All the regular conv, FC layers will be converted to their quantozed counterparts due to quant_modules.initialize()\n",
+ "qat_model = vgg16(num_classes=len(classes), init_weights=False)\n",
+ "qat_model = qat_model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "8e5f7fb5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# vgg16_base_ckpt is the checkpoint generated from Step 3 : Training a baseline VGG16 model.\n",
+ "ckpt = torch.load(\"./vgg16_base_ckpt\")\n",
+ "modified_state_dict={}\n",
+ "for key, val in ckpt[\"model_state_dict\"].items():\n",
+ " # Remove 'module.' from the key names\n",
+ " if key.startswith('module'):\n",
+ " modified_state_dict[key[7:]] = val\n",
+ " else:\n",
+ " modified_state_dict[key] = val\n",
+ "\n",
+ "# Load the pre-trained checkpoint\n",
+ "qat_model.load_state_dict(modified_state_dict)\n",
+ "opt.load_state_dict(ckpt[\"opt_state_dict\"])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8f8a74e8",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 5. Model Calibration"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2a321f9",
+ "metadata": {},
+ "source": [
+ "The quantizer nodes introduced in the model around desired layers capture the dynamic range (min_value, max_value) that is observed by the layer. Calibration is the process of computing the dynamic range of these layers by passing calibration data, which is usually a subset of training or validation data. There are different ways of calibration: `max`, `histogram` and `entropy`. We use `max` calibration technique as it is simple and effective. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "039423dc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def compute_amax(model, **kwargs):\n",
+ " # Load calib result\n",
+ " for name, module in model.named_modules():\n",
+ " if isinstance(module, quant_nn.TensorQuantizer):\n",
+ " if module._calibrator is not None:\n",
+ " if isinstance(module._calibrator, calib.MaxCalibrator):\n",
+ " module.load_calib_amax()\n",
+ " else:\n",
+ " module.load_calib_amax(**kwargs)\n",
+ " print(F\"{name:40}: {module}\")\n",
+ " model.cuda()\n",
+ "\n",
+ "def collect_stats(model, data_loader, num_batches):\n",
+ " \"\"\"Feed data to the network and collect statistics\"\"\"\n",
+ " # Enable calibrators\n",
+ " for name, module in model.named_modules():\n",
+ " if isinstance(module, quant_nn.TensorQuantizer):\n",
+ " if module._calibrator is not None:\n",
+ " module.disable_quant()\n",
+ " module.enable_calib()\n",
+ " else:\n",
+ " module.disable()\n",
+ "\n",
+ " # Feed data to the network for collecting stats\n",
+ " for i, (image, _) in tqdm(enumerate(data_loader), total=num_batches):\n",
+ " model(image.cuda())\n",
+ " if i >= num_batches:\n",
+ " break\n",
+ "\n",
+ " # Disable calibrators\n",
+ " for name, module in model.named_modules():\n",
+ " if isinstance(module, quant_nn.TensorQuantizer):\n",
+ " if module._calibrator is not None:\n",
+ " module.enable_quant()\n",
+ " module.disable_calib()\n",
+ " else:\n",
+ " module.enable()\n",
+ "\n",
+ "def calibrate_model(model, model_name, data_loader, num_calib_batch, calibrator, hist_percentile, out_dir):\n",
+ " \"\"\"\n",
+ " Feed data to the network and calibrate.\n",
+ " Arguments:\n",
+ " model: classification model\n",
+ " model_name: name to use when creating state files\n",
+ " data_loader: calibration data set\n",
+ " num_calib_batch: amount of calibration passes to perform\n",
+ " calibrator: type of calibration to use (max/histogram)\n",
+ " hist_percentile: percentiles to be used for historgram calibration\n",
+ " out_dir: dir to save state files in\n",
+ " \"\"\"\n",
+ "\n",
+ " if num_calib_batch > 0:\n",
+ " print(\"Calibrating model\")\n",
+ " with torch.no_grad():\n",
+ " collect_stats(model, data_loader, num_calib_batch)\n",
+ "\n",
+ " if not calibrator == \"histogram\":\n",
+ " compute_amax(model, method=\"max\")\n",
+ " calib_output = os.path.join(\n",
+ " out_dir,\n",
+ " F\"{model_name}-max-{num_calib_batch*data_loader.batch_size}.pth\")\n",
+ " torch.save(model.state_dict(), calib_output)\n",
+ " else:\n",
+ " for percentile in hist_percentile:\n",
+ " print(F\"{percentile} percentile calibration\")\n",
+ " compute_amax(model, method=\"percentile\")\n",
+ " calib_output = os.path.join(\n",
+ " out_dir,\n",
+ " F\"{model_name}-percentile-{percentile}-{num_calib_batch*data_loader.batch_size}.pth\")\n",
+ " torch.save(model.state_dict(), calib_output)\n",
+ "\n",
+ " for method in [\"mse\", \"entropy\"]:\n",
+ " print(F\"{method} calibration\")\n",
+ " compute_amax(model, method=method)\n",
+ " calib_output = os.path.join(\n",
+ " out_dir,\n",
+ " F\"{model_name}-{method}-{num_calib_batch*data_loader.batch_size}.pth\")\n",
+ " torch.save(model.state_dict(), calib_output)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "78504a6f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Calibrating model\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|███████████████████████████████████████████████████████| 32/32 [00:00<00:00, 96.04it/s]\n",
+ "WARNING: Logging before flag parsing goes to stderr.\n",
+ "W1109 04:01:43.512364 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.513354 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.514046 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.514638 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.515270 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.515859 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.516441 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.517009 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.517600 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.518167 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.518752 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.519333 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.519911 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.520473 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.521038 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.521596 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.522170 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.522742 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.523360 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.523957 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.524581 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525059 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525366 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525675 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.525962 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.526257 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.526566 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.526885 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.527188 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.527489 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.527792 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.528097 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.528387 139704147265344 tensor_quantizer.py:173] Disable MaxCalibrator\n",
+ "W1109 04:01:43.528834 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.529163 139704147265344 tensor_quantizer.py:238] Call .cuda() if running on GPU after loading calibrated amax.\n",
+ "W1109 04:01:43.532748 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([64, 1, 1, 1]).\n",
+ "W1109 04:01:43.533468 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.534033 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([64, 1, 1, 1]).\n",
+ "W1109 04:01:43.534684 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.535320 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([128, 1, 1, 1]).\n",
+ "W1109 04:01:43.535983 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.536569 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([128, 1, 1, 1]).\n",
+ "W1109 04:01:43.537248 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.537833 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).\n",
+ "W1109 04:01:43.538480 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.539074 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).\n",
+ "W1109 04:01:43.539724 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.540307 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([256, 1, 1, 1]).\n",
+ "W1109 04:01:43.540952 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.541534 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.542075 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.542596 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.543248 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.543719 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.544424 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.544952 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.545530 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.546114 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.546713 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.547292 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([512, 1, 1, 1]).\n",
+ "W1109 04:01:43.547902 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.548453 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.549015 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([4096, 1]).\n",
+ "W1109 04:01:43.549665 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.550436 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([4096, 1]).\n",
+ "W1109 04:01:43.551925 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([]).\n",
+ "W1109 04:01:43.553105 139704147265344 tensor_quantizer.py:237] Load calibrated amax, shape=torch.Size([10, 1]).\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "features.0._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=2.7537 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.0._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0263, 2.7454](64) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.3._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=27.5676 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.3._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0169, 1.8204](64) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.7._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=15.2002 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.7._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0493, 1.3207](128) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.10._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=7.7376 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.10._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0163, 0.9624](128) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.14._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=8.8351 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.14._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0622, 0.8791](256) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.17._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=12.5746 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.17._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0505, 0.5117](256) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.20._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=9.7203 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.20._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0296, 0.5335](256) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.24._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=8.9367 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.24._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0220, 0.3763](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.27._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=6.6539 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.27._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0151, 0.1777](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.30._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=3.7099 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.30._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0087, 0.1906](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.34._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=4.0491 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.34._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0106, 0.1971](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.37._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=2.1531 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.37._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0070, 0.2305](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.40._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=3.3631 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "features.40._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0023, 0.4726](512) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "avgpool._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=5.3550 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.0._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=5.3550 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.0._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0026, 0.5320](4096) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.3._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=6.6733 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.3._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.0018, 0.5172](4096) calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.6._input_quantizer : TensorQuantizer(8bit narrow fake per-tensor amax=9.4352 calibrator=MaxCalibrator scale=1.0 quant)\n",
+ "classifier.6._weight_quantizer : TensorQuantizer(8bit narrow fake axis=0 amax=[0.3877, 0.5620](10) calibrator=MaxCalibrator scale=1.0 quant)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Calibrate the model using max calibration technique.\n",
+ "with torch.no_grad():\n",
+ " calibrate_model(\n",
+ " model=qat_model,\n",
+ " model_name=\"vgg16\",\n",
+ " data_loader=training_dataloader,\n",
+ " num_calib_batch=32,\n",
+ " calibrator=\"max\",\n",
+ " hist_percentile=[99.9, 99.99, 99.999, 99.9999],\n",
+ " out_dir=\"./\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1aa0c109",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 6. Quantization Aware Training"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9fe8ec11",
+ "metadata": {},
+ "source": [
+ "In this phase, we finetune the model weights and leave the quantizer node values frozen. The dynamic ranges for each layer obtained from the calibration are kept constant while the weights of the model are finetuned to be close to the accuracy of original FP32 model (model without quantizer nodes) is preserved. Usually the finetuning of QAT model should be quick compared to the full training of the original model. Use QAT to fine-tune for around 10% of the original training schedule with an annealing learning-rate. Please refer to Achieving FP32 Accuracy for INT8 Inference Using Quantization Aware Training with NVIDIA TensorRT for detailed recommendations. For this VGG model, it is enough to finetune for 1 epoch to get acceptable accuracy. \n",
+ "During finetuning with QAT, the quantization is applied as a composition of `max`, `clamp`, `round` and `mul` ops. \n",
+ "```\n",
+ "# amax is absolute maximum value for an input\n",
+ "# The upper bound for integer quantization (127 for int8)\n",
+ "max_bound = torch.tensor((2.0**(num_bits - 1 + int(unsigned))) - 1.0, device=amax.device)\n",
+ "scale = max_bound / amax\n",
+ "outputs = torch.clamp((inputs * scale).round_(), min_bound, max_bound)\n",
+ "```\n",
+ "tensor_quant function in `pytorch_quantization` toolkit is responsible for the above tensor quantization. Usually, per channel quantization is recommended for weights, while per tensor quantization is recommended for activations in a network.\n",
+ "During inference, we use `torch.fake_quantize_per_tensor_affine` and `torch.fake_quantize_per_channel_affine` to perform quantization as this is easier to convert into corresponding TensorRT operators. Please refer to next sections for more details on how these operators are exported in torchscript and converted in Torch-TensorRT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "1f28d228",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Updating learning rate: 0.1\n",
+ "Epoch: [ 1 / 1] LR: 0.100000\n",
+ "Batch: [ 500 | 1563] loss: 2.635\n",
+ "Batch: [ 1000 | 1563] loss: 2.655\n",
+ "Batch: [ 1500 | 1563] loss: 2.646\n",
+ "Test Loss: 0.03291 Test Acc: 82.98%\n",
+ "Checkpoint saved\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Finetune the QAT model for 1 epoch\n",
+ "num_epochs=1\n",
+ "for epoch in range(num_epochs):\n",
+ " adjust_lr(opt, epoch)\n",
+ " print('Epoch: [%5d / %5d] LR: %f' % (epoch + 1, num_epochs, state[\"lr\"]))\n",
+ "\n",
+ " train(qat_model, training_dataloader, crit, opt, epoch)\n",
+ " test_loss, test_acc = test(qat_model, testing_dataloader, crit, epoch)\n",
+ "\n",
+ " print(\"Test Loss: {:.5f} Test Acc: {:.2f}%\".format(test_loss, 100 * test_acc))\n",
+ " \n",
+ "save_checkpoint({'epoch': epoch + 1,\n",
+ " 'model_state_dict': qat_model.state_dict(),\n",
+ " 'acc': test_acc,\n",
+ " 'opt_state_dict': opt.state_dict(),\n",
+ " 'state': state},\n",
+ " ckpt_path=\"vgg16_qat_ckpt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a4dcaa2",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 7. Export to Torchscript\n",
+ "Export the model to Torch script. Trace the model and convert it into torchscript for deployment. To learn more about Torchscript, please refer to https://pytorch.org/docs/stable/jit.html. Setting `quant_nn.TensorQuantizer.use_fb_fake_quant = True` enables the QAT model to use `torch.fake_quantize_per_tensor_affine` and `torch.fake_quantize_per_channel_affine` operators instead of `tensor_quant` function to export quantization operators. In torchscript, they are represented as `aten::fake_quantize_per_tensor_affine` and `aten::fake_quantize_per_channel_affine`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "3d34f526",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "E1109 04:02:37.101168 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.102248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.107194 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.107625 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.115269 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.115740 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.117969 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.118358 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.126382 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.126834 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.128674 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.129518 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.135453 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.135936 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.137858 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.138366 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.145539 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.146053 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.147871 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.148353 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.154252 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.154685 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.156558 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.157159 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.163197 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.163676 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.165549 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.165991 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.173305 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.173926 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.176034 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.176697 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.182843 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.183426 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.185377 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.185962 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.191966 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.192424 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.194325 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.194817 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.201988 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.202665 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.204763 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.205461 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.211393 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.211987 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.213899 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.214450 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.220892 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.221533 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.223519 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.224037 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.233809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.234434 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.238212 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.239042 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.241022 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.241654 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.247820 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.248445 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.250366 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.250959 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.257248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.257854 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.259968 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.260660 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "W1109 04:02:37.268160 139704147265344 tensor_quantizer.py:280] Use Pytorch's native experimental fake quantization.\n",
+ "/opt/conda/lib/python3.8/site-packages/pytorch_quantization/nn/modules/tensor_quantizer.py:285: TracerWarning: Converting a tensor to a Python number might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+ " inputs, amax.item() / bound, 0,\n",
+ "/opt/conda/lib/python3.8/site-packages/pytorch_quantization/nn/modules/tensor_quantizer.py:291: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+ " quant_dim = list(amax.shape).index(list(amax_sequeeze.shape)[0])\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "E1109 04:02:37.329273 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.330212 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.332529 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.333365 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.339547 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.340248 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.342257 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.342890 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.350619 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.351372 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.353470 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.354121 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.360090 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.360806 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.362803 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.363274 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.370369 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.371057 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.373071 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.373766 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.379890 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.380538 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.382532 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.383128 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.389077 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.389760 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.391815 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.392399 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.399809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.400472 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.402399 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.402939 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.408818 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.409424 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.411513 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.412097 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.418537 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.419128 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.421343 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.421946 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.429382 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.430156 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.432259 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.433079 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.439297 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.440027 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.442149 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.442826 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.449377 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.449968 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.452122 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.452754 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.462532 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.463295 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.466963 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.467725 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.469692 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.470336 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.476204 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.476738 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.478809 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.479375 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.485666 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.486219 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.488416 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n",
+ "E1109 04:02:37.488986 139704147265344 tensor_quantizer.py:120] Fake quantize mode doesn't use scale explicitly!\n"
+ ]
+ }
+ ],
+ "source": [
+ "quant_nn.TensorQuantizer.use_fb_fake_quant = True\n",
+ "with torch.no_grad():\n",
+ " data = iter(testing_dataloader)\n",
+ " images, _ = data.next()\n",
+ " jit_model = torch.jit.trace(qat_model, images.to(\"cuda\"))\n",
+ " torch.jit.save(jit_model, \"trained_vgg16_qat.jit.pt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7341418a",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 8. Inference using Torch-TensorRT\n",
+ "In this phase, we run the exported torchscript graph of VGG QAT using Torch-TensorRT. Torch-TensorRT is a Pytorch-TensorRT compiler which converts Torchscript graphs into TensorRT. TensorRT 8.0 supports inference of quantization aware trained models and introduces new APIs; `QuantizeLayer` and `DequantizeLayer`. We can observe the entire VGG QAT graph quantization nodes from the debug log of Torch-TensorRT. To enable debug logging, you can set `torch_tensorrt.logging.set_reportable_log_level(torch_tensorrt.logging.Level.Debug)`. For example, `QuantConv2d` layer from `pytorch_quantization` toolkit is represented as follows in Torchscript\n",
+ "```\n",
+ "%quant_input : Tensor = aten::fake_quantize_per_tensor_affine(%x, %636, %637, %638, %639)\n",
+ "%quant_weight : Tensor = aten::fake_quantize_per_channel_affine(%394, %640, %641, %637, %638, %639)\n",
+ "%input.2 : Tensor = aten::_convolution(%quant_input, %quant_weight, %395, %687, %688, %689, %643, %690, %642, %643, %643, %644, %644)\n",
+ "```\n",
+ "`aten::fake_quantize_per_*_affine` is converted into `QuantizeLayer` + `DequantizeLayer` in Torch-TensorRT internally. Please refer to quantization op converters in Torch-TensorRT."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "aa7495e0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING: [Torch-TensorRT] - Cannot infer input type from calcuations in graph for input x.2. Assuming it is Float32. If not, specify input type explicity\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT] - Dilation not used in Max pooling converter\n",
+ "WARNING: [Torch-TensorRT TorchScript Conversion Context] - Detected invalid timing cache, setup a local cache instead\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "VGG QAT accuracy using TensorRT: 82.97%\n"
+ ]
+ }
+ ],
+ "source": [
+ "qat_model = torch.jit.load(\"trained_vgg16_qat.jit.pt\").eval()\n",
+ "\n",
+ "compile_spec = {\"inputs\": [torch_tensorrt.Input([16, 3, 32, 32])],\n",
+ " \"enabled_precisions\": torch.int8,\n",
+ " }\n",
+ "trt_mod = torch_tensorrt.compile(qat_model, **compile_spec)\n",
+ "\n",
+ "test_loss, test_acc = test(trt_mod, testing_dataloader, crit, 0)\n",
+ "print(\"VGG QAT accuracy using TensorRT: {:.2f}%\".format(100 * test_acc))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9df5a90e",
+ "metadata": {},
+ "source": [
+ "### Performance benchmarking"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "9eb2cd2d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "import numpy as np\n",
+ "\n",
+ "import torch.backends.cudnn as cudnn\n",
+ "cudnn.benchmark = True\n",
+ "\n",
+ "# Helper function to benchmark the model\n",
+ "def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=1000):\n",
+ " input_data = torch.randn(input_shape)\n",
+ " input_data = input_data.to(\"cuda\")\n",
+ " if dtype=='fp16':\n",
+ " input_data = input_data.half()\n",
+ " \n",
+ " print(\"Warm up ...\")\n",
+ " with torch.no_grad():\n",
+ " for _ in range(nwarmup):\n",
+ " features = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " print(\"Start timing ...\")\n",
+ " timings = []\n",
+ " with torch.no_grad():\n",
+ " for i in range(1, nruns+1):\n",
+ " start_time = time.time()\n",
+ " output = model(input_data)\n",
+ " torch.cuda.synchronize()\n",
+ " end_time = time.time()\n",
+ " timings.append(end_time - start_time)\n",
+ " if i%100==0:\n",
+ " print('Iteration %d/%d, avg batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))\n",
+ "\n",
+ " print(\"Input shape:\", input_data.size())\n",
+ " print(\"Output shape:\", output.shape)\n",
+ " print('Average batch time: %.2f ms'%(np.mean(timings)*1000))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "5c2514ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, avg batch time 4.83 ms\n",
+ "Iteration 200/1000, avg batch time 4.83 ms\n",
+ "Iteration 300/1000, avg batch time 4.83 ms\n",
+ "Iteration 400/1000, avg batch time 4.83 ms\n",
+ "Iteration 500/1000, avg batch time 4.83 ms\n",
+ "Iteration 600/1000, avg batch time 4.83 ms\n",
+ "Iteration 700/1000, avg batch time 4.83 ms\n",
+ "Iteration 800/1000, avg batch time 4.83 ms\n",
+ "Iteration 900/1000, avg batch time 4.83 ms\n",
+ "Iteration 1000/1000, avg batch time 4.83 ms\n",
+ "Input shape: torch.Size([16, 3, 32, 32])\n",
+ "Output shape: torch.Size([16, 10])\n",
+ "Average batch time: 4.83 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(jit_model, input_shape=(16, 3, 32, 32))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "c5378ed6",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Warm up ...\n",
+ "Start timing ...\n",
+ "Iteration 100/1000, avg batch time 1.87 ms\n",
+ "Iteration 200/1000, avg batch time 1.84 ms\n",
+ "Iteration 300/1000, avg batch time 1.85 ms\n",
+ "Iteration 400/1000, avg batch time 1.83 ms\n",
+ "Iteration 500/1000, avg batch time 1.82 ms\n",
+ "Iteration 600/1000, avg batch time 1.81 ms\n",
+ "Iteration 700/1000, avg batch time 1.81 ms\n",
+ "Iteration 800/1000, avg batch time 1.80 ms\n",
+ "Iteration 900/1000, avg batch time 1.80 ms\n",
+ "Iteration 1000/1000, avg batch time 1.79 ms\n",
+ "Input shape: torch.Size([16, 3, 32, 32])\n",
+ "Output shape: torch.Size([16, 10])\n",
+ "Average batch time: 1.79 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "benchmark(trt_mod, input_shape=(16, 3, 32, 32))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d6a5ec1c",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 9. References\n",
+ "* Very Deep Convolution Networks for large scale Image Recognition\n",
+ "* Achieving FP32 Accuracy for INT8 Inference Using Quantization Aware Training with NVIDIA TensorRT\n",
+ "* QAT workflow for VGG16\n",
+ "* Deploying VGG QAT model in C++ using Torch-TensorRT\n",
+ "* Pytorch-quantization toolkit from NVIDIA\n",
+ "* Pytorch quantization toolkit userguide\n",
+ "* Quantization basics"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/v1.1.1/_sources/cli/torchtrtc.rst.txt b/docs/v1.1.1/_sources/cli/torchtrtc.rst.txt
new file mode 100644
index 0000000000..68f599a5cd
--- /dev/null
+++ b/docs/v1.1.1/_sources/cli/torchtrtc.rst.txt
@@ -0,0 +1,146 @@
+.. _torchtrtc:
+
+torchtrtc
+=================================
+
+``torchtrtc`` is a CLI application for using the Torch-TensorRT compiler. It serves as an easy way to compile a
+TorchScript Module with Torch-TensorRT from the command-line to quickly check support or as part of
+a deployment pipeline. All basic features of the compiler are supported including post training
+quantization (though you must already have a calibration cache file to use the PTQ feature). The compiler can
+output two formats, either a TorchScript program with the TensorRT engine embedded or
+the TensorRT engine itself as a PLAN file.
+
+All that is required to run the program after compilation is for C++ linking against ``libtorchtrt.so``
+or in Python importing the torch_tensorrt package. All other aspects of using compiled modules are identical
+to standard TorchScript. Load with ``torch.jit.load()`` and run like you would run any other module.
+
+.. code-block:: txt
+
+ torchtrtc [input_file_path] [output_file_path]
+ [input_specs...] {OPTIONS}
+
+ torchtrtc is a compiler for TorchScript, it will compile and optimize
+ TorchScript programs to run on NVIDIA GPUs using TensorRT
+
+ OPTIONS:
+
+ -h, --help Display this help menu
+ Verbiosity of the compiler
+ -v, --verbose Dumps debugging information about the
+ compilation process onto the console
+ -w, --warnings Disables warnings generated during
+ compilation onto the console (warnings
+ are on by default)
+ --i, --info Dumps info messages generated during
+ compilation onto the console
+ --build-debuggable-engine Creates a debuggable engine
+ --allow-gpu-fallback (Only used when targeting DLA
+ (device-type)) Lets engine run layers on
+ GPU if they are not supported on DLA
+ --require-full-compilation Require that the model should be fully
+ compiled to TensorRT or throw an error
+ --check-method-support=[method_name]
+ Check the support for end to end
+ compilation of a specified method in the
+ TorchScript module
+ --disable-tf32 Prevent Float32 layers from using the
+ TF32 data format
+ --sparse-weights Enable sparsity for weights of conv and
+ FC layers
+ -p[precision...],
+ --enable-precision=[precision...] (Repeatable) Enabling an operating
+ precision for kernels to use when
+ building the engine (Int8 requires a
+ calibration-cache argument) [ float |
+ float32 | f32 | fp32 | half | float16 |
+ f16 | fp16 | int8 | i8 | char ]
+ (default: float)
+ -d[type], --device-type=[type] The type of device the engine should be
+ built for [ gpu | dla ] (default: gpu)
+ --gpu-id=[gpu_id] GPU id if running on multi-GPU platform
+ (defaults to 0)
+ --dla-core=[dla_core] DLACore id if running on available DLA
+ (defaults to 0)
+ --engine-capability=[capability] The type of device the engine should be
+ built for [ standard | safety |
+ dla_standalone ]
+ --calibration-cache-file=[file_path]
+ Path to calibration cache file to use
+ for post training quantization
+ --teo=[op_name...],
+ --torch-executed-op=[op_name...] (Repeatable) Operator in the graph that
+ should always be run in PyTorch for
+ execution (partial compilation must be
+ enabled)
+ --tem=[module_name...],
+ --torch-executed-mod=[module_name...]
+ (Repeatable) Module that should always
+ be run in Pytorch for execution (partial
+ compilation must be enabled)
+ --mbs=[num_ops],
+ --min-block-size=[num_ops] Minimum number of contiguous TensorRT
+ supported ops to compile a subgraph to
+ TensorRT
+ --embed-engine Whether to treat input file as a
+ serialized TensorRT engine and embed it
+ into a TorchScript module (device spec
+ must be provided)
+ --num-avg-timing-iters=[num_iters]
+ Number of averaging timing iterations
+ used to select kernels
+ --workspace-size=[workspace_size] Maximum size of workspace given to
+ TensorRT
+ --dla-sram-size=[dla_sram_size] Fast software managed RAM used by DLA
+ to communicate within a layer.
+ --dla-local-dram-size=[dla_local_dram_size] Host RAM used by DLA to share
+ intermediate tensor data across operations.
+ --dla-global-dram-size=[dla_global_dram_size] Host RAM used by DLA to store
+ weights and metadata for execution
+ --atol=[atol] Absolute tolerance threshold for acceptable
+ numerical deviation from standard torchscript
+ output (default 1e-8)
+ --rtol=[rtol] Relative tolerance threshold for acceptable
+ numerical deviation from standard torchscript
+ output (default 1e-5)
+ --no-threshold-check Skip checking threshold compliance
+ --truncate-long-double,
+ --truncate, --truncate-64bit Truncate weights that are provided in
+ 64bit to 32bit (Long, Double to Int,
+ Float)
+ --save-engine Instead of compiling a full a
+ TorchScript program, save the created
+ engine to the path specified as the
+ output path
+ --custom-torch-ops (repeatable) Shared object/DLL containing custom torch operators
+ --custom-converters (repeatable) Shared object/DLL containing custom converters
+ input_file_path Path to input TorchScript file
+ output_file_path Path for compiled TorchScript (or
+ TensorRT engine) file
+ input_specs... Specs for inputs to engine, can either
+ be a single size or a range defined by
+ Min, Optimal, Max sizes, e.g.
+ "(N,..,C,H,W)"
+ "[(MIN_N,..,MIN_C,MIN_H,MIN_W);(OPT_N,..,OPT_C,OPT_H,OPT_W);(MAX_N,..,MAX_C,MAX_H,MAX_W)]".
+ Data Type and format can be specified by
+ adding an "@" followed by dtype and "%"
+ followed by format to the end of the
+ shape spec. e.g. "(3, 3, 32,
+ 32)@f16%NHWC"
+ "--" can be used to terminate flag options and force all following
+ arguments to be treated as positional options
+
+e.g.
+
+.. code-block:: shell
+
+ torchtrtc tests/modules/ssd_traced.jit.pt ssd_trt.ts "[(1,3,300,300); (1,3,512,512); (1, 3, 1024, 1024)]@f16%contiguous" -p f16
+
+
+To run with custom torch operators
+.. code-block:: shell
+torchtrtc tests/modules/ssd_traced.jit.pt ssd_trt.ts --custom-torch-ops=