PyTorch Documentation
Attributes
Classs
Environments
Exceptions
Functions
Guides
Methods
Modules
Propertys
Sections
- (Prototype - maintenance mode) FX Graph Mode Quantization
- 0, 1 are always specialized
- A Gentle Introduction to Dynamo
- A Note on Tuning Behavior
- A Quick Primer on Graphs
- A Simple Custom Module
- A simple example
- AArch64 CPU
- AMD/ROCm/HIP
- AOTInductor: Ahead-Of-Time Compilation for Torch.Export-ed Models
- API Methods
- API Reference
- API Reference
- API Reference
- API Reference
- API Reference
- API Reference
- API Reference
- API usage logging
- API: the important bits
- ASGD
- ATen operators
- ATen operators
- About Open Source Development
- About the tensor subclass
- Abridged internal API
- Abridged public API
- Accelerating nn.Linear with semi-structured sparsity
- Access package contents from packaged code?
- Accessing Module Parameters
- Accessing TorchDynamo Profiler
- Accessing real and imag
- Accuracy Debugging
- Acknowledgements
- Active Memory Timeline
- Adadelta
- Adagrad
- Adam
- AdamW
- Adamax
- AdaptiveAvgPool1d
- AdaptiveAvgPool2d
- AdaptiveAvgPool3d
- AdaptiveLogSoftmaxWithLoss
- AdaptiveMaxPool1d
- AdaptiveMaxPool2d
- AdaptiveMaxPool3d
- Add, Remove, and Re-Scope Modules and Projects
- Adding Test Cases to Make the Codebase More Robust
- Adding Tutorials
- Adding a Module
- Adding new operators
- Adding support for an aten or quantized operator
- Adding support for operators
- Advanced Features
- Algorithms
- Aliases
- Allocator State History
- AlphaDropout
- An Example
- Analyzing a module’s dependencies
- Analyzing an object’s dependencies
- Angle and abs
- Annotate Function Signature
- Annotate Variables and Data Attributes
- Annotated Assignment Statements
- Any Type
- Appendix
- Apple M1/MPS
- Arithmetic Conversions
- Arithmetic Operators
- Assignment Statements
- Assumptions
- Assumptions
- Asynchronous Execution
- Asynchronous Execution
- Asynchronous execution
- Asynchronous multiprocess training (e.g. Hogwild)
- Atoms
- Attaching metadata to saved TorchScript models
- Attention Mechanisms
- Attribute
- Attribute Lookup On Python Modules
- Attribute References
- Attributes
- Augmented Assignment Statements
- Authoring Models in C++
- Autocast Op Reference
- Autocast and Custom Autograd Functions
- Autocast and Custom Autograd Functions
- Autocasting
- Autograd
- Autograd (torch.autograd)
- Autograd for Complex Numbers
- Autograd for Complex Numbers
- Autograd graph
- Autograd mechanics
- Autograd recording during the forward pass
- Autograd support
- Autograd support
- Automatic Mixed Precision examples
- Automatic Mixed Precision examples
- Automatic Mixed Precision package - torch.amp
- Automatic Trace Checking
- Automatic batching (default)
- Automatically generate a vmap rule
- Available Debuggers
- AvgPool1d
- AvgPool2d
- AvgPool3d
- Avoid CPU oversubscription
- Avoid NumPy and built-in Python types
- Avoid Tensor.data
- Avoid global state in your modules
- Avoid in-place operations when using tensor.shape in tracing mode
- Avoiding Pitfalls
- Avoiding and fighting deadlocks
- Avoiding nondeterministic algorithms
- BC note: Using grads on the default stream
- BCELoss
- BCEWithLogitsLoss
- BLAS and LAPACK Operations
- BNReLU2d
- BNReLU2d
- BNReLU3d
- BNReLU3d
- Backend/Hardware Support
- BackendConfig
- BackendPatternConfig
- Backends
- Backends
- Backends
- Backends that come with PyTorch
- Background
- Background
- Backward Hooks execution
- BackwardCFunction
- Backwards compatibility
- Base class
- Base class
- BasePruningMethod
- Basic Usage
- Basic if/else Statement
- Basic name inference rules
- Basics
- Basics
- Basics
- Basics of using torch.profiler and viewing traces
- BatchNorm1d
- BatchNorm2d
- BatchNorm2d
- BatchNorm3d
- BatchNorm3d
- Batched computations or slice computations
- Behavior of Tensor hooks when Tensor is modified in-place
- Benchmark Individual Triton Kernel
- Bernoulli
- Best Practices
- Best Practices for Backends
- Best practices
- Best practices and tips
- Beta
- Bilinear
- Binary Arithmetic Operations
- Binary Bitwise Operations
- Binary Operators
- Binomial
- Boolean Operations
- Break and Continue
- Breakdown Model GPU Time
- Broadcasting semantics
- Build + CI
- Build environment considerations
- Build from source
- Build options
- Building from source
- Built-in Class
- Built-in Functions and Modules
- Built-in Functions and Modules
- C++
- C++ API
- C++ Docs
- C++ Operators
- C10 utils and operator dispatch
- C10d Backend
- CELU
- CFFI Extension
- CPU Op-Specific Behavior
- CPU Op-Specific Behavior
- CPU Ops that can autocast to bfloat16
- CPU Ops that can autocast to float32
- CPU Ops that promote to the widest input type
- CPU Performance (Torch Inductor / MKLDNN)
- CPU in multiprocessing
- CPU oversubscription
- CPU threading and TorchScript inference
- CPU threading and TorchScript inference
- CSR Tensor Operations
- CTCLoss
- CUDA API to HIP API mappings in C++
- CUDA API to HIP API mappings in C++
- CUDA Environment Variables
- CUDA Graphs
- CUDA Graphs
- CUDA IPC operations
- CUDA Op-Specific Behavior
- CUDA Op-Specific Behavior
- CUDA Ops that can autocast to float16
- CUDA Ops that can autocast to float32
- CUDA Ops that promote to the widest input type
- CUDA RNN and LSTM
- CUDA Stream Sanitizer
- CUDA convolution benchmarking
- CUDA convolution determinism
- CUDA in multiprocessing
- CUDA in multiprocessing
- CUDA semantics
- CUDA streams
- CUDAGraph
- CUDAGraph Background
- CUDAGraph Trees
- CUDAGraph Trees Integration
- CUDAPluggableAllocator
- Caching logic
- CallMethodKey
- Calling torch.func transform inside of a function handled with torch.compile
- Calls
- Can I check if my PR affects TorchInductor’s performance on the dashboard before merging?
- Can I compile NumPy code using torch.compile?
- Can I execute NumPy code on CUDA and compute gradients via torch.compile?
- Capability Based Partitioner
- Casts
- Categorical
- Cauchy
- CausalBias
- CausalVariant
- ChainedScheduler
- ChannelShuffle
- Check availability for Intel GPU
- Checking Correctness of Modules
- Checking for HIP
- Checkpointing of Communication Hooks
- Chi2
- Choosing the network interface to use
- CircularPad1d
- CircularPad2d
- CircularPad3d
- Classes
- Client Methods
- Cold Start Timing and Cache Corruption Debugging
- Collective functions
- Combined or separate forward() and setup_context()
- Combined or separate forward() and setup_context()
- Common Errors
- Common Mistakes To Avoid
- Common Pitfalls in Transform Authoring
- Common environment variables
- Common extension points
- Communication collectives
- Communication payload size
- Communication payload size
- Comparison Operators
- Comparison Ops
- Comparisons
- Comparisons
- Compilers (JIT / TorchScript / FX / TorchDynamo)
- Compiling functions besides the ones which are supported (escape hatch)
- Compiling torch.func.grad with torch.compile
- Compiling torch.vmap with torch.compile
- Complex Numbers
- Complex Numbers
- Complex-to-real functions
- Composable Backends
- Compound Statements
- Computing dependencies
- Concepts
- Conclusion
- Concurrency on CPU
- Conditional Expressions
- ConstantLR
- ConstantPad1d
- ConstantPad2d
- ConstantPad3d
- Constants
- Constraints
- Constraints
- Constructing Sparse Semi-Structured Tensors
- Constructing averaged models
- Constructing it
- Construction
- Construction
- Construction of BSC tensors
- Construction of BSR tensors
- Construction of CSC tensors
- Construction of CSR tensors
- Construction of sparse compressed tensors
- Containers
- Context method mixins
- ContinuousBernoulli
- Contracts away dims
- Contracts away dims
- Contributing / Developing
- Contributing a New Tutorial
- Contribution Process
- Control Flow
- Control Flow - Cond
- Control Flow - Cond
- Controlling sources of randomness
- Controversial Decision Process
- Conv1d
- Conv1d
- Conv2d
- Conv2d
- Conv2d
- Conv3d
- Conv3d
- Conv3d
- ConvBn1d
- ConvBn1d
- ConvBn2d
- ConvBn2d
- ConvBn3d
- ConvBn3d
- ConvBnReLU1d
- ConvBnReLU1d
- ConvBnReLU2d
- ConvBnReLU2d
- ConvBnReLU3d
- ConvBnReLU3d
- ConvReLU1d
- ConvReLU1d
- ConvReLU2d
- ConvReLU2d
- ConvReLU2d
- ConvReLU3d
- ConvReLU3d
- ConvReLU3d
- ConvTranspose1d
- ConvTranspose1d
- ConvTranspose2d
- ConvTranspose2d
- ConvTranspose3d
- ConvTranspose3d
- ConvertCustomConfig
- ConvertIntKey
- Convolution Layers
- Convolution functions
- Core Aten IR
- Core Maintainers
- Core Maintainers
- CosineAnnealingLR
- CosineAnnealingWarmRestarts
- CosineEmbeddingLoss
- CosineSimilarity
- Cpp Extension
- Creating Complex Tensors
- Creating TorchScript Code
- Creating named tensors
- Creating new custom ops in Python
- Creation Ops
- Creation Ops
- CrossEntropyLoss
- Current Tunable Operators
- Currently supported operations and subsystems
- Custom Backends
- Custom Backends after AOTAutograd
- Custom Class
- Custom Function utilities
- Custom averaging strategies
- Custom operators
- CustomFromMask
- Customization
- Customize how a class is packaged?
- Customizing Tracing with the Tracer class
- Customizing Tracing with the Tracer class
- CyclicLR
- DDP Communication Hooks
- DTypeConfig
- DTypeWithConstraints
- Data Loading Order and Sampler
- Data insensitive error
- Data sensitive error
- Data types
- Data-dependent Python control flow
- Data-dependent operations (.item())
- Data/Shape-Dependent Control Flow
- DataLoader
- DataParallel
- DataParallel functions (multi-GPU, distributed)
- DataParallel in a single process
- DataParallel in a single process
- Dataclasses
- Dataset Types
- DeQuantStub
- Debugging
- Debugging
- Debugging Backend
- Debugging Communication Hooks
- Debugging Environment Variables
- Debugging and anomaly detection
- Debugging the Generated Code
- Debugging the Transformation
- Debugging torch.distributed applications
- Decision Making
- Decompositions
- Default Communication Hooks
- Default Mode (Grad Mode)
- Default Types
- Default backward mode gradcheck behavior
- Default complex input analytical evaluation
- Default complex input numerical evaluation
- Default gradient layouts
- Default gradient layouts
- Default real input analytical evaluation
- Default real input numerical evaluation
- Default values for native configurations
- Defining the vmap staticmethod
- Definitions
- Dependencies
- Dependency Management
- Deployment
- Design Notes
- Design Notes
- Design Principles
- Design Reasoning
- Details
- Device-agnostic code
- DeviceMesh
- Diagnosing Runtime Errors
- Diagnosing TorchInductor Errors
- Diagnosing issues with SARIF
- Dict Construction
- Differences in Operator Implementations
- DimConstraints
- DimDynamic
- DimDynamic policy
- Direct Graph Manipulation
- Dirichlet
- Disable JIT for Debugging
- Disable JIT for Debugging
- Disable automatic batching
- Discovering all unconvertible ATen ops at once
- Distance Functions
- Distance functions
- Distinguish between packaged code and non-packaged code?
- Distributed
- Distributed Autograd Context
- Distributed Autograd Design
- Distributed Autograd Framework
- Distributed Backward Pass
- Distributed Checkpoint - torch.distributed.checkpoint
- Distributed Data Parallel
- Distributed Data Parallel
- Distributed Key-Value Store
- Distributed Optimizer
- Distributed Optimizer
- Distributed Optimizers
- Distributed RPC Framework
- Distributed Training
- Distributed communication package - torch.distributed
- DistributedDataParallel
- DistributedDataParallel
- DistributedDataParallel, multiple GPUs per process
- DistributedDataParallel, one GPU per process
- Distribution
- Distributions & RNG
- DivideByKey
- Do I still need to export whole graphs?
- Do you support Distributed code?
- Docs / Tutorials
- Documentation
- Does NumPy work with torch.compile?
- Does torch.compile support training?
- Does torch.func work with torch.compile (for grad and vmap transforms)?
- Dropout
- Dropout Layers
- Dropout functions
- Dropout1d
- Dropout2d
- Dropout3d
- Duck shaping
- Dynamic Control Flow
- Dynamic Rendezvous
- Dynamic shape operations (nonzero and friends)
- Dynamic shapes
- Dynamo Deep-Dive
- Dynamo Deep-Dive
- Dynamo Internals
- Dynamo Overview
- ELU
- ELU
- Eager Mode Quantization
- Embedding
- Embedding
- EmbeddingBag
- EmbeddingBag
- Enabling TunableOp and Tuning Separately
- Enabling kernel asserts
- EnforceUnique
- Enum Type
- Environment Variables
- Environment variable initialization
- EqualityConstraint
- Error Propagation
- Etcd Backend
- Etcd Rendezvous (Legacy)
- Etcd Server
- Etcd Store
- Evaluation Mode (nn.Module.eval())
- Event
- Event
- Event
- Event
- Event Objects
- Events
- Events Handler
- Example
- Example
- Example 1: autograd.Function calls into another system
- Example 2: autograd.Function specifies custom gradient rules
- Example: AlexNet from PyTorch to ONNX
- Examples
- Examples
- Examples
- Examples
- Examples of the Interpreter Pattern
- Exceptions
- Excessive Recompilation
- Existing frameworks
- Experimental Functions
- Explanation
- Explicit alignment by names
- Exponential
- ExponentialFamily
- ExponentialLR
- Export Path
- ExportDB
- ExportDB
- ExportedProgram
- Exporting a PyTorch Model
- Expressing Dynamism
- Expression Lists
- Expression Statements
- Expressions
- Expressions
- Extended Debugging
- Extending PyTorch
- Extending PyTorch and TorchScript with C++ Extensions
- Extending all torch API with Modes
- Extending custom ops (created from Python or C++)
- Extending the Agent
- Extending torch Python API
- Extending torch Python API
- Extending torch native API
- Extending torch native API
- Extending torch with a Tensor wrapper type
- Extending torch with a Tensor-like type
- Extending torch.autograd
- Extending torch.autograd
- Extending torch.func with autograd.Function
- Extending torch.func with autograd.Function
- Extending torch.nn
- Extension
- ExternalStream
- Extremal values
- Extremal values in linalg
- FAQ
- FAST mode algorithm
- FSDP Notes
- FSDP Prefetch Nuances
- FSDP Prefetch Nuances
- FSDP buffers sizes
- FXFloatFunctional
- Factory functions
- Factory functions
- Failure Modes
- Fake tensor
- Fake tensor of fake tensor?
- FakeQuantize
- FakeQuantizeBase
- FakeTensor
- Fast Fourier Transform (torch.fft)
- Fast Fourier Transforms
- Fast backward mode gradcheck
- Fast complex input analytical evaluation
- Fast complex input numerical evaluation
- Fast gradcheck for complex-to-real functions
- Fast gradcheck for functions with complex outputs
- Fast gradcheck for real-to-real functions
- FeatureAlphaDropout
- Features for large-scale deployments
- File Input and Output
- File descriptor - file_descriptor
- File system - file_system
- Filling uninitialized memory
- Finding graph breaks: “Torch-Compiled Region” and “CompiledFunction”
- FisherSnedecor
- FixedQParamsFakeQuantize
- Flatten
- Fleet-wide operator profiling
- FloatFunctional
- Fold
- Footnotes
- For loops over constant nn.ModuleList
- For loops over tuples
- For loops with range
- Foreach Operations
- Forward mode AD
- Forward mode AD
- Forward-mode Automatic Differentiation
- Forward-mode Automatic Differentiation
- FractionalMaxPool2d
- FractionalMaxPool3d
- Framework files
- Frequently Asked Questions
- Frequently Asked Questions
- Frequently Asked Questions
- Frequently Asked Questions
- Frequently Asked Questions
- Frequently Asked Questions
- Function
- Function Calls
- Function Transforms
- Functional higher level API
- Functional higher level API
- Functionality overview
- Functions
- Functions
- Functions
- Functions
- Functions
- Functions Not Correctly Bound on Torch
- Functions that need a particular dtype
- Functions with complex outputs
- Functions with multiple inputs or autocastable ops
- FuseCustomConfig
- FusedMovingAvgObsFakeQuantize
- Fusion Backends
- GELU
- GLU
- GPU Performance (Torch Inductor / Triton / CUDA)
- GRU
- GRU
- GRUCell
- GRUCell
- Gamma
- GaussianNLLLoss
- General Project Policies
- General Quantization Flow
- General limitations
- General semantics
- General tips
- Generating a Snapshot
- Generating the Output Graph
- Generator
- Generators
- Generic Join Context Manager
- Geometric
- Get Started
- Getting Started
- Getting Started
- Getting Started
- Grad Modes
- Gradcheck mechanics
- Gradgradcheck implementation
- Gradient Scaling
- Gradient accumulation
- Gradient clipping
- Gradient penalty
- Gradients for non-differentiable functions
- Gradients for non-differentiable functions
- Graph
- Graph Breaks
- Graph Breaks
- Graph Breaks
- Graph Breaks
- Graph Manipulation
- Graph Manipulation Examples
- Graph memory management
- Graph retaining
- GraphInfo
- Graphs (beta)
- GroupNorm
- GroupNorm
- Groups
- Guards on symbolic ints
- Gumbel
- HIP (ROCm) semantics
- HIP (ROCm) semantics
- HIP Interfaces Reuse the CUDA Interfaces
- HIP Interfaces Reuse the CUDA Interfaces
- HalfCauchy
- HalfNormal
- Handler
- Hardshrink
- Hardsigmoid
- Hardswish
- Hardswish
- Hardtanh
- Hardware Prerequisites
- Health Check Server
- Helper Functions
- HingeEmbeddingLoss
- HistogramObserver
- Hogwild
- Hooks for saved tensors
- Hooks for saved tensors
- How are you speeding up my code?
- How autograd encodes the history
- How autograd encodes the history
- How can I run any performance test locally?
- How can I write my own derivative formula for a complex function?
- How do I debug NumPy code under torch.compile?
- How do I graph break on a function?
- How do I…
- How does PyTorch compute the conjugate Wirtinger derivative?
- How does the converter work?
- How does the pipeline API split a model?
- How is Wirtinger Calculus useful in optimization?
- How is each individual operator implemented?
- How to Add a New Maintainer
- How to Use a Communication Hook?
- How to adjust learning rate
- How to fix
- How to implement an entrypoint?
- How to inspect artifacts generated by Dynamo?
- How to read the dashboard?
- How to use
- How to use an optimizer
- How torch.package finds your code’s dependencies
- How torch.package keeps packages isolated from each other
- HuberLoss
- Hugging Face Examples
- I torch.compile some NumPy code and I did not see any speed-up.
- IRs
- IRs
- Identifiers
- Identifying the Cause of a Graph Break
- Identifying the cause of a graph break
- Identity
- Identity
- Identity Comparisons
- Idioms for working with meta tensors
- If Statements
- Implementation
- Implementation
- Implementation error
- Implementations
- Implementations
- Implementing CPython in Python
- Implementing Features or Fixing Bugs
- Implementing Your Own Schedule
- Import error
- Important Notice
- Important Notices
- Improving Code Readability
- Improving Documentation & Tutorials
- Improving Memory Usage with Pruning
- Improving Performance with Quantization
- In-place correctness checks
- In-place correctness checks
- In-place operations on Tensors
- In-place operations with autograd
- In-place random sampling
- In-place random sampling
- In-place semantics
- Include arbitrary resources with my package and access them later?
- Include optional components
- Independent
- Index
- Indexing, Slicing, Joining, Mutating Ops
- Indexing, Slicing, Joining, Mutating Ops
- Indices and tables
- Inference Examples
- Inference Mode
- Inference in C++
- Inference with AMP
- Inference with FP32
- Inference with torch.compile
- Initialization
- Initializing and basic operations
- Inline Autograd Function
- InnerTensorKey
- InplaceFunction
- Input Tensor Shapes
- Inspecting Code
- Inspecting the ONNX model using GUI
- Installation
- Instance Data Attributes
- InstanceNorm1d
- InstanceNorm1d
- InstanceNorm2d
- InstanceNorm2d
- InstanceNorm3d
- InstanceNorm3d
- Int8 quantization tips
- Intel Instrumentation and Tracing Technology APIs
- Interaction with dynamic shapes
- Internal Design
- Interpreting Graphs
- Interval
- Introduction
- Introduction
- Introduction
- Introduction to Quantization
- Invariants of torch.ops.higher_order.cond
- InverseGamma
- Inverses
- Inverses
- Iterable-style datasets
- Iterables
- Iterables
- JitScalarType
- Jiterator (beta)
- Just-in-Time Compilation
- Just-in-Time Compilation
- KLDivLoss
- Keeps input names
- Keeps input names
- Kernel
- KinetoStepTracker
- Known Issues
- Known limitations:
- Kumaraswamy
- L1Loss
- L1Unstructured
- LBFGS
- LKJCholesky
- LPPool1d
- LPPool2d
- LPPool3d
- LSTM
- LSTM
- LSTM
- LSTMCell
- LSTMCell
- LambdaLR
- Laplace
- Launch overhead
- Launch utility
- Launcher
- LayerNorm
- LayerNorm
- Lazy Modules Initialization
- LazyBatchNorm1d
- LazyBatchNorm2d
- LazyBatchNorm3d
- LazyConv1d
- LazyConv2d
- LazyConv3d
- LazyConvTranspose1d
- LazyConvTranspose2d
- LazyConvTranspose3d
- LazyInstanceNorm1d
- LazyInstanceNorm2d
- LazyInstanceNorm3d
- LazyLinear
- LazyModuleMixin
- Lead Core Maintainer (BDFL)
- Lead Core Maintainer (BDFL)
- Leaf Modules
- LeakyReLU
- LeakyReLU
- Library-level maintainers
- Limitations
- Limitations
- Limitations
- Limitations and gotchas
- Limitations of Symbolic Tracing
- Limitations of torch.export
- Linear
- Linear
- Linear
- Linear
- Linear
- Linear Algebra
- Linear Algebra (torch.linalg)
- Linear Algebra operations
- Linear Layers
- Linear algebra (torch.linalg)
- Linear algebra (torch.linalg)
- Linear functions
- LinearLR
- LinearReLU
- LinearReLU
- LinearReLU
- LinearReLU
- List Construction
- List and Dictionary Displays
- List of supported operators
- Literals
- Literals
- LnStructured
- Loading Batched and Non-Batched Data
- Loading models from Hub
- Local Variables
- LocalResponseNorm
- Locally disabling gradient computation
- Locally disabling gradient computation
- Locally disabling gradient computation
- Locally disabling gradient computation
- Locally disabling gradient computation
- Locally disabling gradient computation
- LogNormal
- LogSigmoid
- LogSoftmax
- Logging
- Logical Operators
- LogitRelaxedBernoulli
- Loss Functions
- Loss functions
- Low-level APIs
- LowRankMultivariateNormal
- MPS Event
- MPS Profiler
- MPS backend
- MSELoss
- Make Graphed Callables
- Making Dynamo Complete: Graph Breaks
- Making Dynamo Sound: Guards
- Mangling
- Manipulating dimensions
- Manual gradient layouts
- Map-style datasets
- MarginRankingLoss
- MaskedTensor (torch.masked)
- Math operations
- Matrix Functions
- Matrix Products
- Matrix Properties
- MaxPool1d
- MaxPool2d
- MaxPool3d
- MaxUnpool1d
- MaxUnpool2d
- MaxUnpool3d
- MemRecordsAcc
- Membership Changes
- Membership Test Operations
- Memory Pinning
- Memory management
- Memory management
- Memory management
- Memory management
- Memory management
- Memory management
- Meta Programming
- Meta Programming
- Meta Types
- Meta device
- Metadata
- Method Calls
- Methods
- Methods and Classes
- Metric Handler
- Metric Handlers
- Metrics
- Migrating from functorch to torch.func
- Migrating to PyTorch 1.2 Recursive Scripting API
- MinMaxObserver
- Minifying Backend Compiler Errors
- Minifying TorchInductor Errors
- Minimum Code Change
- Misc
- Miscellanea
- Miscellaneous Environment Variables
- Mish
- Missing Fake/Meta/Abstract Kernels for Operators
- Mixing Tracing and Scripting
- MixtureSameFamily
- Mobile / Edge
- Model Compilation
- Model Compression & Optimization
- Model Preparation for Eager Mode Static Quantization
- Model Split APIs
- Module
- Module Attributes
- Module Hooks
- Module Index
- Module Initialization
- Module Instance Class
- Module Maintainers
- Module State
- Module-level maintainers
- ModuleDict
- ModuleList
- Modules
- Modules
- Modules as Building Blocks
- Monitored Barrier
- Motivation
- Motivation
- Motivation
- MovingAverageMinMaxObserver
- MovingAveragePerChannelMinMaxObserver
- Multi-GPU collective functions
- Multi-process data loading
- MultiLabelMarginLoss
- MultiLabelSoftMarginLoss
- MultiMarginLoss
- MultiStepLR
- MultiheadAttention
- MultiheadAttention
- Multinomial
- MultiplicativeLR
- Multiprocessing and DataLoaders
- Multiprocessing best practices
- Multiprocessing error without if-clause protection
- Multiprocessing error “Broken pipe”
- Multiprocessing error “driver shut down”
- Multiprocessing package - torch.multiprocessing
- Multithreaded Autograd
- MultivariateNormal
- Mutation: Arbitrary mutation of Python data structures
- Mutation: in-place PyTorch Operations
- Mutation: out= PyTorch Operations
- My GPU memory isn’t freed properly
- My data loader workers return identical random numbers
- My data loader workers return identical random numbers
- My model reports “cuda runtime error(2): out of memory”
- My out of memory exception handler can’t allocate memory
- My recurrent network doesn’t work with data parallelism
- My recurrent network doesn’t work with data parallelism
- NAdam
- NCCL < 2.9.6
- NCCL >= 2.9.6
- NLLLoss
- NN APIs (torch.nn)
- NN module utilities
- NNModule Hooks Support
- NVFuser
- NVIDIA Tools Extension (NVTX)
- Name propagation semantics
- Named Tensors
- Named Tensors
- Named Tensors operator coverage
- Named Tensors operator coverage
- Named Tuples
- Named dimensions
- Named tensor API reference
- NegativeBinomial
- Nested tensor constructor and conversion functions
- Nested tensor constructor and conversion functions
- NestedIOFunction
- NestedTensor (torch.nested)
- Neural Network Training with Modules
- Next Steps
- No thread safety on C++ hooks
- No-grad Mode
- Node
- Nominal Types
- Nominating Core Maintainers
- Nominating, Confirming and Removing Maintainers
- Non-Strict Export
- Non-constraints
- Non-determinism
- Non-finite values
- Non-linear Activations (other)
- Non-linear Activations (weighted sum, nonlinearity)
- Non-linear activation functions
- Non-torch Functions
- NoopObserver
- Normal
- Normalization Layers
- Not Supported Yet
- Notations and background information
- Note for native CPU backends
- Note on rendezvous backend
- Numerical Debugging Tooling (prototype)
- Numerical accuracy
- Numerical gradient checking
- ONNX Backend for TorchDynamo
- ONNX exporter
- ONNX exporter internals
- ONNX supported TorchScript operators
- ONNX-script functions
- ObservationType
- Observer and FakeQuantize
- ObserverBase
- On Documentation
- One key install script
- One-to-None Pass
- One-to-One Pass
- One-to-X Pass
- OneCycleLR
- OneHotCategorical
- Op Eligibility
- Op Eligibility
- Operations on multiple types that define __torch_function__
- Operator Kernels
- Operator Support
- Operator Tags
- Operator overview
- Operators
- Operators Supported for Any Type
- Ops With Divergent Schemas Between Torch & Python
- Optimizations
- Optimizers
- Optimizers (torch.optim)
- Optimizing memory usage with PYTORCH_CUDA_ALLOC_CONF
- Optimizing memory usage with PYTORCH_CUDA_ALLOC_CONF
- Option 1: Change the BatchNorm
- Option 1: splitting a model manually
- Option 1: splitting a model manually
- Option 2: splitting a model automatically
- Option 2: splitting a model automatically
- Option 2: torchvision parameter
- Option 3: functorch’s patching
- Option 4: eval mode
- Optional Type Refinement
- Options for Splitting a Model
- Other NCCL environment variables
- Other Operations
- Other functions
- Other resources
- Overall architecture
- Overall architecture
- Overview
- Overview
- Overview
- Overview
- Owner Share RRef with User
- PEP 523: Adding a frame evaluation API to CPython
- PReLU
- PYTORCH ProcessGroupNCCL Environment Variables
- PYTORCH ProcessGroupNCCL Environment Variables
- Package a TorchScript module?
- Package not found in win-32 channel.
- Packaging for C++
- Packaging your first model
- PackedSequence
- Padding Layers
- PairwiseDistance
- Parallelism
- Parameter
- ParameterDict
- ParameterList
- ParametrizationList
- Parametrizations
- Parenthesized Forms
- Pareto
- Partial-network capture
- Participating in Online Discussions
- Partitioner
- Pass Manager
- Passes
- Passing a non-quantized Tensor into a quantized kernel
- Passing a quantized Tensor into a non-quantized kernel
- Patch code into a package?
- Patching Batch Norm
- Pathwise derivative
- Pattern Matching Assignments
- Patterns
- Per-parameter options
- PerChannelMinMaxObserver
- Performance Profiling
- Performance Tools
- Performance characteristics
- Permutes dimensions
- Permutes dimensions
- Pipeline Parallelism
- PixelShuffle
- PixelUnshuffle
- PlaceholderObserver
- Platform-specific behaviors
- Point-to-point communication
- Pointwise Ops
- Poisson
- PoissonNLLLoss
- PolynomialLR
- Pooling functions
- Pooling layers
- Post Training Dynamic Quantization
- Post Training Static Quantization
- Post-Initialization
- Power Operator
- PowerPC
- PowerSGD Communication Hook
- PowerSGD Hooks
- PowerSGD State
- Prefer binary_cross_entropy_with_logits over binary_cross_entropy
- PrepareCustomConfig
- Preparing model for quantization
- Primaries
- Primitive Types
- Prims IR
- Principle 1: Usability over Performance
- Principle 2: Simple Over Easy
- Principle 3: Python First with Best In Class Language Interoperability
- Print Statements
- Print the Generated Code
- Process Context
- ProcessGroup
- Profiler
- Profiling Collective Communication
- Profiling Performance
- Profiling to understand torch.compile performance
- Promoting PyTorch
- PropagateUnbackedSymInts
- Proposing New Features
- Protocol Scenarios
- Proxy/Retracing
- PruningContainer
- Publishing models
- Putting it all together: EMA
- Putting it all together: SWA
- PyTorch 2.0 NNModule Support
- PyTorch 2.0 Performance Dashboard
- PyTorch 2.0 Troubleshooting
- PyTorch API
- PyTorch CUDAGraph Integration
- PyTorch Contribution Guide
- PyTorch Custom Operators Landing Page
- PyTorch Custom Operators Landing Page
- PyTorch Design Philosophy
- PyTorch Functions and Modules
- PyTorch Governance | Build + CI
- PyTorch Governance | Maintainers
- PyTorch Governance | Mechanics
- PyTorch Unsupported Modules and Classes
- PyTorch documentation
- PyTorch random number generator
- Python
- Python Breakpoint
- Python Built-in Functions
- Python Built-in Functions
- Python Built-in Functions Support
- Python Built-in Functions Support
- Python Built-in Values Support
- Python Built-in Values Support
- Python Containers
- Python Docs
- Python Functions and Modules
- Python Language Reference Comparison
- Python Language Reference Coverage
- Python Language Reference Coverage
- Python Primitives
- Python Values
- Python Values
- Python-defined Constants
- Python-defined Constants
- Pytorch 2.4: Getting Started on Intel GPU
- Pytree-able Types
- QConfig
- QConfig
- QConfigMapping
- QFunctional
- QuantStub
- QuantWrapper
- Quantization
- Quantization API Reference
- Quantization API Reference
- Quantization API Summary
- Quantization Accuracy Debugging
- Quantization Accuracy Debugging
- Quantization Aware Training for Static Quantization
- Quantization Backend Configuration
- Quantization Backend Configuration
- Quantization Custom Module API
- Quantization Customizations
- Quantization Flow
- Quantization Flow Support
- Quantization Mode Support
- Quantization Stack
- Quantization Support Matrix
- Quantize and Dequantize
- Quantized Engine
- Quantized Functions
- Quantized Model
- Quantized Operators/Modules
- Quantized Tensor
- Quantized dtypes and quantization schemes
- Quasi-random sampling
- Quickstart
- RAdam
- RMSNorm
- RMSNorm
- RMSprop
- RNN
- RNNBase
- RNNCell
- RNNCell
- RPC
- RReLU
- RRef
- RRef Lifetime
- Random Number Generator
- Random Number Generator
- Random number generators in other libraries
- Random sampling
- RandomStructured
- RandomUnstructured
- Randomness
- Randomness in multi-process data loading
- Randomness in multi-process data loading
- Re-export an imported object?
- ReLU
- ReLU6
- ReLU6
- Read More
- Read More
- Read More
- Reads / Gets
- Real-to-real functions
- RecordingObserver
- Recurrent Layers
- ReduceLROnPlateau
- Reduced Precision FP16 and BF16 GEMMs and Convolutions on AMD Instinct MI200 devices
- Reduced Precision FP16 and BF16 GEMMs and Convolutions on AMD Instinct MI200 devices
- Reduced Precision Reduction for FP16 and BF16 GEMMs
- Reduced Precision Reduction in BF16 GEMMs
- Reduced Precision Reduction in BF16 GEMMs
- Reduced Precision Reduction in FP16 GEMMs
- Reduced Precision Reduction in FP16 GEMMs
- Reduction Ops
- Reductions
- Refactoring
- Refer to CUDA Semantics doc
- References
- References
- ReflectionPad1d
- ReflectionPad2d
- ReflectionPad3d
- Registering Custom Backends
- Registering default hooks for saved tensors
- Registering hooks for a saved tensor
- Registry
- Reinitialization
- Related work
- RelaxedBernoulli
- RelaxedOneHotCategorical
- RelaxedUnspecConstraint
- Relevant Environment Variables
- Remote Procedure Calls
- Remote Procedure Calls
- Remote Reference Protocol
- RemoteModule
- RemoteModule
- Removes dimensions
- Removes dimensions
- Removing the Lead Core Maintainer and Nominating a New Lead Core Maintainer
- Rendezvous
- Rendezvous Handler
- ReplicationPad1d
- ReplicationPad2d
- ReplicationPad3d
- Reporting Issues
- Reproducibility
- Resolution Rules
- Resolution Rules
- Responsibilities
- Retrieve SubprocessHandler
- Return
- Reuse buffers passed through a Queue
- Reviewing Open Pull Requests
- Rprop
- Running a loaded model:
- Runtime API
- SDPBackend
- SELU
- SGD
- SMART mode algorithm
- SWA learning rate schedules
- Saved tensors
- Saved tensors
- Saving and Loading Quantized models
- Saving and loading ScriptModules across PyTorch versions
- Saving and loading ScriptModules across PyTorch versions
- Saving and loading tensors
- Saving and loading tensors
- Saving and loading tensors preserves views
- Saving and loading tensors preserves views
- Saving and loading torch.nn.Modules
- Saving and loading torch.nn.Modules
- Score function
- ScriptFunction
- ScriptModule
- Search Page
- See what is inside a package?
- See why a given module was included as a dependency?
- Sequential
- SequentialLR
- Serialization
- Serialization
- Serialization
- Serialization semantics
- Serialized file format for torch.save
- Serialized file format for torch.save
- Serializing torch.nn.Modules and loading them in C++
- Serializing torch.nn.Modules and loading them in C++
- Server/Client Implementations
- Set up Environment
- Setting requires_grad
- ShapeEnv
- ShapeEnvSettings
- Shared file-system initialization
- Sharing CUDA tensors
- Sharing CUDA tensors
- Sharing memory across captures
- Sharing strategies
- Shifting Operations
- Shuffle Layers
- Shutdown
- SiLU
- Sigmoid
- Sigmoid
- Simple Assignments
- Simple Statements
- Simple end to end example
- Single- and Multi-process Data Loading
- Single-node multi-worker
- Single-process data loading (default)
- Slicings
- SmoothL1Loss
- Snapshot API Reference
- SobolEngine
- SoftMarginLoss
- Softmax
- Softmax2d
- Softmin
- Softplus
- Softshrink
- Softsign
- Software Prerequisites
- Solvers
- Solvers
- Sparse (torch.sparse)
- Sparse BSC Tensor
- Sparse BSC Tensor
- Sparse BSR Tensor
- Sparse BSR Tensor
- Sparse COO tensors
- Sparse COO tensors
- Sparse CSC Tensor
- Sparse CSC Tensor
- Sparse CSR Tensor
- Sparse CSR Tensor
- Sparse Compressed Tensors
- Sparse Compressed Tensors
- Sparse Layers
- Sparse Semi-Structured Tensor Operations
- Sparse Semi-Structured Tensors
- Sparse Semi-Structured Tensors
- Sparse functions
- Sparse hybrid COO tensors
- Sparse hybrid COO tensors
- SparseAdam
- Spawn utility
- Spawning subprocesses
- Special Note on torch.nn.ModuleList and torch.nn.ModuleDict
- Special hooks
- Specializations
- Spectral Ops
- Speeding CUDA build for Windows
- Speedy Backend
- Stacked single-node multi-worker
- StandaloneModuleConfigEntry
- Starting Multiple Workers
- StatefulSymbolicContext
- StatelessSymbolicContext
- Statements
- Static Control Flow
- Static Symbolic Method
- Static by default
- Step 1: build PipelineStage for execution
- Step 2: use PipelineSchedule for execution
- StepLR
- Strategy management
- Stream
- Stream
- Stream
- Stream
- Stream Sanitizer (prototype)
- Stream semantics of backward passes
- Stream semantics of backward passes
- StreamContext
- StreamContext
- StreamContext
- StreamContext
- Streams and events
- Streams and events
- Streams and events
- Streams and events
- StrictMinMaxConstraint
- StringTable
- Structural Types
- StudentT
- SubclassSymbolicContext
- Subclassing torch.Tensor
- Subgraph Matcher
- Subgraph Rewriter
- Subgraph Rewriting With replace_pattern()
- Submitting Pull Requests to Fix Open Issues
- Submodules
- Subprocess Handling
- SubprocessHandler
- Subscriptions
- Subscripts and Slicing
- Subsystems
- Summary
- Supported
- Supported Operators
- Supported PyTorch Functions
- Supported Tensor Methods
- Supported operations
- Supported operations
- Supported operations
- Supported operators
- SymInt
- Symbolic Numbers
- Symbolic Shapes
- Symbolic Trace Error when using FX Graph Mode Quantization
- SymbolicContext
- SyncBatchNorm
- Synchronous and asynchronous collective operations
- TCP initialization
- TORCH_DISTRIBUTED_DEBUG
- Taking an optimization step
- Taking care of batch normalization
- Tanh
- Tanhshrink
- Technical Deep Dive
- Tensor Attributes
- Tensor Attributes
- Tensor Operations
- Tensor Parallelism - torch.distributed.tensor.parallel
- Tensor Views
- Tensor Views
- Tensor and Autograd in C++
- Tensor autograd functions
- Tensor class reference
- Tensor methods and sparse
- TensorFloat-32 (TF32) on Ampere (and later) devices
- TensorFloat-32 (TF32) on Ampere (and later) devices
- TensorFloat-32(TF32) on Nvidia Ampere (and later) devices
- TensorFloat-32(TF32) on ROCm
- TensorFloat-32(TF32) on ROCm
- TensorPipe Backend
- Tensors
- Terminology
- Terminology
- Ternary Expressions
- Ternary if/else Statement
- Test in my source code whether or not it is executing inside a package?
- Testing Coverage of Overrides for the PyTorch API
- Testing custom ops
- The Guard Model
- The Interpreter Pattern
- The Principles
- The Process for Nomination
- The Process for Removal
- The assert Statement
- The break Statement
- The continue Statement:
- The del Statement
- The enumerate Statement
- The for-in Statement
- The getattr Statement
- The hasattr Statement
- The if Statement
- The order in which the different hooks are fired
- The pass Statement
- The print Statement
- The raise Statement
- The return Statement
- The tuple Statement
- The while Statement
- The with Statement
- The zip Statement
- Third-party backends
- Third-party backends
- Thread Safety on Autograd Node
- Threading Environment Variables
- Threshold
- Tools for working with sparse compressed tensors
- Top level APIs
- Torch Distributed Elastic
- Torch Environment Variables
- Torch and Tensor Unsupported Attributes
- Torch functions specific to sparse Tensors
- TorchAudio
- TorchData / TorchArrow
- TorchDynamo APIs for fine-grained tracing
- TorchDynamo APIs for fine-grained tracing
- TorchDynamo DDPOptimizer
- TorchDynamo Previous CUDA Graphs Integration
- TorchDynamo-based ONNX Exporter
- TorchDynamo-based ONNX Exporter
- TorchElastic Kubernetes
- TorchInductor Debugging using TORCH_COMPILE_DEBUG
- TorchInductor GPU Profiling
- TorchRec
- TorchScript
- TorchScript Builtin Functions
- TorchScript Builtins
- TorchScript Builtins
- TorchScript C++ API
- TorchScript Classes
- TorchScript Classes
- TorchScript Classes
- TorchScript Classes
- TorchScript Enums
- TorchScript Enums
- TorchScript Enums
- TorchScript Language
- TorchScript Language Reference
- TorchScript Language Reference
- TorchScript Language Reference
- TorchScript Language Reference
- TorchScript Module Class
- TorchScript Type System Definition
- TorchScript Types
- TorchScript Unsupported PyTorch Constructs
- TorchScript Unsupported PyTorch Constructs
- TorchScript-based ONNX Exporter
- TorchScript-based ONNX Exporter
- TorchServe
- TorchText
- TorchVision
- TorchX
- Torchdynamo Errors
- Tracer
- Tracer Warnings
- Tracing Edge Cases
- Tracing vs Scripting
- Train script
- Train script
- Train with AMP
- Train with FP32
- Training Examples
- TransformedDistribution
- Transformer
- Transformer
- Transformer Layers
- TransformerDecoder
- TransformerDecoderLayer
- TransformerEncoder
- TransformerEncoderLayer
- Transforming Modules with FX
- Transition from the old representation
- Transitioning from torch.distributed.launch to torchrun
- Treat the package like a ZIP archive
- Triaging Issues
- TripletMarginLoss
- TripletMarginWithDistanceLoss
- TunableGemm for ROCm
- TunableOp
- TunableOp
- Tuning Context
- Tuning the number of threads
- Tuple Construction
- Tutorials
- Tutorials
- Tutorials
- Tutorials Build Overview
- Type Annotation
- Type Annotation APIs
- Type Annotation Appendix
- Type Annotations
- Type Annotations
- Type Info
- Type Info
- Type Refinement
- Type Refinement
- Type System
- Types
- Types
- Types
- Types are not shared between packages and the loading environment
- Typical Mixed Precision Training
- UX Limitations
- Unary Operators
- Unary and Arithmetic Bitwise Operations
- Unary functions
- Unbacked SymInts
- Uncoalesced sparse COO tensors
- Uncoalesced sparse COO tensors
- Uncontroversial Changes
- Understanding CUDA Memory Usage
- Understanding CUDA Memory Usage
- Understanding compilation time
- Unflatten
- Unfold
- Unifies names from inputs
- Unifies names from inputs
- Uniform
- UninitializedBuffer
- UninitializedParameter
- UnpackedDualTensor
- Unsupported Tensor Indexing Patterns
- Unsupported Tensor Indexing Patterns
- Unsupported Tensor Methods
- Unsupported Tensor Properties
- Unsupported Typing Constructs
- Unsupported Typing Constructs
- Unsupported operators
- Upsample
- UpsamplingBilinear2d
- UpsamplingNearest2d
- Usage
- Usage
- Usage (multiprocessing)
- Usage with DistributedDataParallel
- Usage with multiple streams
- Usage with multiple streams
- Usage with torch.cuda.amp
- Usage with torch.cuda.amp
- Use nn.parallel.DistributedDataParallel instead of multiprocessing or nn.DataParallel
- Use nn.parallel.DistributedDataParallel instead of multiprocessing or nn.DataParallel
- Use of Python Values
- Use pdb
- Use pinned memory buffers
- Use pinned memory buffers
- Use the file_structure() API
- Use the to_folder Function From GraphModule
- User Share RRef with Owner as Argument
- User Share RRef with Owner as Return Value
- User Share RRef with User
- User files
- Using a pretrained model
- Using custom memory allocators for CUDA
- Using custom memory allocators for CUDA
- Using the visualizer
- Utilities
- Utilities for working with torch.nn.Modules
- Utility functions
- Utility functions
- Utilizing Local Information
- Utils
- Value Comparisons
- Variable (deprecated)
- Variable Resolution
- Variables
- Variables
- Variables
- VerificationOptions
- View and select functions
- Vision Layers
- Vision functions
- VonMises
- Watchdog in the Agent
- Weibull
- Weight Averaging (SWA and EMA)
- What Does a Communication Hook Operate On?
- What about cross-domain functions?
- What are complex derivatives?
- What are composable function transforms?
- What are the transforms?
- What is Dynamo doing?
- What is Export IR
- What is a MaskedTensor?
- What is a guard?
- What is measured on the dashboard?
- What is torch.distributed.pipelining?
- What is torch.func?
- What to use torch.profiler for:
- What’s happening?
- What’s the difference between torch._dynamo.disable and torch._dynamo.disallow_in_graph
- What’s the difference between torch._dynamo.disable and torch._dynamo_skip
- When not to use
- When to Annotate Types
- When to use
- Where are my downloaded models saved?
- Whether a particular hook will be fired
- Which API to use for fine grain tracing?
- Which NumPy features does torch.compile support?
- Which NumPy features does torch.compile support?
- Which backend to use?
- While Loops
- Whole-network capture
- Why CUDA Graphs?
- Why Pipeline Parallel?
- Why am I getting OOMs?
- Why am I getting incorrect results?
- Why am I not seeing speedups?
- Why and when to use sparsity
- Why are you recompiling in production?
- Why composable function transforms?
- Why composable function transforms?
- Why didn’t my code recompile when I changed it?
- Why is compilation slow?
- Why is my code crashing?
- Why not use a complex u
- Windows
- Windows FAQ
- Wirtinger Calculus comes into the picture …
- Wishart
- Working around CUDA Graph profiling issues
- Working with Multiple GPUs
- Working with Multiple GPUs
- Working with Multiple Models, Losses, and Optimizers
- Working with Scaled Gradients
- Working with Unscaled Gradients
- Working with collate_fn
- Working with collate_fn
- Working with sparse COO tensors
- Writes / Sets
- Writing Graph Transformations on ATen IR
- Writing Transformations
- Writing a custom timer server/client
- XLA
- XPU Op-Specific Behavior (Experimental)
- XPU Op-Specific Behavior (Experimental)
- XPU Ops that can autocast to float16
- XPU Ops that can autocast to float32
- XPU Ops that promote to the widest input type
- ZeroPad1d
- ZeroPad2d
- ZeroPad3d
- adaptive_avg_pool2d
- adaptive_avg_pool3d
- add_quant_dequant
- assume_constant_result
- assume_constant_result
- autograd_function
- avg_pool2d
- avg_pool3d
- call_function
- celu
- check_sparse_tensor_invariants
- clamp
- class_method
- cond_branch_class_method
- cond_branch_class_method
- cond_branch_class_method
- cond_branch_nested_function
- cond_branch_nested_function
- cond_branch_nested_function
- cond_branch_nonlocal_variables
- cond_branch_nonlocal_variables
- cond_branch_nonlocal_variables
- cond_closed_over_variable
- cond_closed_over_variable
- cond_closed_over_variable
- cond_operands
- cond_operands
- cond_operands
- cond_predicate
- cond_predicate
- cond_predicate
- constrain_as_size_example
- constrain_as_size_example
- constrain_as_size_example
- constrain_as_value_example
- constrain_as_value_example
- constrain_as_value_example
- conv1d
- conv2d
- conv3d
- convert
- convert_fx
- cuBLAS workspaces
- cuFFT plan cache
- data_parallel
- decorator
- default_activation_only_qconfig
- default_debug_observer
- default_debug_qconfig
- default_dynamic_qconfig
- default_dynamic_quant_observer
- default_eval_fn
- default_fake_quant
- default_float_qparams_observer
- default_fused_act_fake_quant
- default_fused_per_channel_wt_fake_quant
- default_fused_wt_fake_quant
- default_histogram_fake_quant
- default_histogram_observer
- default_observer
- default_per_channel_qconfig
- default_per_channel_weight_fake_quant
- default_per_channel_weight_observer
- default_placeholder_observer
- default_qat_qconfig
- default_qat_qconfig_v2
- default_qconfig
- default_weight_fake_quant
- default_weight_observer
- default_weight_only_qconfig
- device
- device
- device
- device_of
- device_of
- dictionary
- dictionary
- disable_fake_quant
- disable_observer
- dual_level
- dynamic_shape_assert
- dynamic_shape_assert
- dynamic_shape_constructor
- dynamic_shape_constructor
- dynamic_shape_if_guard
- dynamic_shape_if_guard
- dynamic_shape_if_guard
- dynamic_shape_map
- dynamic_shape_map
- dynamic_shape_map
- dynamic_shape_round
- dynamic_shape_round
- dynamic_shape_round
- dynamic_shape_slicing
- dynamic_shape_slicing
- dynamic_shape_view
- dynamic_shape_view
- elu
- enable_fake_quant
- enable_grad
- enable_observer
- extern
- float16_dynamic_qconfig
- float16_static_qconfig
- float_qparams_weight_only_qconfig
- fn_with_kwargs
- fn_with_kwargs
- freeze_bn_stats
- function transforms
- functorch.combine_state_for_ensemble
- functorch.compile
- functorch.make_functional
- fuse_fx
- fuse_modules
- get_attr
- get_default_qat_qconfig_mapping
- get_default_qconfig_mapping
- get_observer_state_dict
- grad() (gradient computation)
- graph
- hardsigmoid
- hardswish
- hardtanh
- henry2019
- hipFFT/rocFFT plan cache
- hipFFT/rocFFT plan cache
- inference_mode
- intern
- interpolate
- jacrev(), jacfwd(), and hessian()
- jvp() (Jacobian-vector product)
- leaky_relu
- linear
- list_contains
- list_contains
- list_contains
- list_contains
- list_unpack
- list_unpack
- list_unpack
- load_observer_state_dict
- match semantics
- match semantics
- math Module
- max_pool1d
- max_pool2d
- mock
- model_attr_mutation
- model_attr_mutation
- model_is_exported
- nested_function
- nested_function
- nn.Module.__call__ Hooks Usage and limitations
- no_grad
- null_context_manager
- null_context_manager
- optimizer.step()
- optimizer.step(closure)
- optional_input
- optional_input
- out function and in-place variants
- out function and in-place variants
- output
- per_channel_dynamic_qconfig
- placeholder
- prepare
- prepare_fx
- prepare_qat
- prepare_qat_fx
- propagate_qconfig
- python.assert
- python.builtin
- python.closure
- python.context-manager
- python.control-flow
- python.data-structure
- python.object-model
- pytree_flatten
- quantize
- quantize_dynamic
- quantize_qat
- record_function
- scalar_output
- scalar_output
- set_grad_enabled
- set_multithreading_enabled
- size
- specialized_attribute
- state_dict Hooks
- static_for_loop
- static_for_loop
- static_if
- static_if
- strict_fusion
- swap_module
- tensor_setattr
- tensor_setattr
- threshold
- torch (quantization related functions)
- torch.* APIs
- torch.* APIs
- torch.Size
- torch.Storage
- torch.Tensor
- torch.Tensor
- torch.Tensor (quantization related methods)
- torch.Tensor.abs
- torch.Tensor.abs_
- torch.Tensor.absolute
- torch.Tensor.absolute_
- torch.Tensor.acos
- torch.Tensor.acos_
- torch.Tensor.acosh
- torch.Tensor.acosh_
- torch.Tensor.add
- torch.Tensor.add_
- torch.Tensor.addbmm
- torch.Tensor.addbmm_
- torch.Tensor.addcdiv
- torch.Tensor.addcdiv_
- torch.Tensor.addcmul
- torch.Tensor.addcmul_
- torch.Tensor.addmm
- torch.Tensor.addmm_
- torch.Tensor.addmv
- torch.Tensor.addmv_
- torch.Tensor.addr
- torch.Tensor.addr_
- torch.Tensor.adjoint
- torch.Tensor.all
- torch.Tensor.allclose
- torch.Tensor.amax
- torch.Tensor.amin
- torch.Tensor.aminmax
- torch.Tensor.angle
- torch.Tensor.any
- torch.Tensor.apply_
- torch.Tensor.arccos
- torch.Tensor.arccos_
- torch.Tensor.arccosh
- torch.Tensor.arccosh_
- torch.Tensor.arcsin
- torch.Tensor.arcsin_
- torch.Tensor.arcsinh
- torch.Tensor.arcsinh_
- torch.Tensor.arctan
- torch.Tensor.arctan2
- torch.Tensor.arctan2_
- torch.Tensor.arctan_
- torch.Tensor.arctanh
- torch.Tensor.arctanh_
- torch.Tensor.argmax
- torch.Tensor.argmin
- torch.Tensor.argsort
- torch.Tensor.argwhere
- torch.Tensor.as_strided
- torch.Tensor.as_subclass
- torch.Tensor.asin
- torch.Tensor.asin_
- torch.Tensor.asinh
- torch.Tensor.asinh_
- torch.Tensor.atan
- torch.Tensor.atan2
- torch.Tensor.atan2_
- torch.Tensor.atan_
- torch.Tensor.atanh
- torch.Tensor.atanh_
- torch.Tensor.backward
- torch.Tensor.baddbmm
- torch.Tensor.baddbmm_
- torch.Tensor.bernoulli
- torch.Tensor.bernoulli_
- torch.Tensor.bfloat16
- torch.Tensor.bincount
- torch.Tensor.bitwise_and
- torch.Tensor.bitwise_and_
- torch.Tensor.bitwise_left_shift
- torch.Tensor.bitwise_left_shift_
- torch.Tensor.bitwise_not
- torch.Tensor.bitwise_not_
- torch.Tensor.bitwise_or
- torch.Tensor.bitwise_or_
- torch.Tensor.bitwise_right_shift
- torch.Tensor.bitwise_right_shift_
- torch.Tensor.bitwise_xor
- torch.Tensor.bitwise_xor_
- torch.Tensor.bmm
- torch.Tensor.bool
- torch.Tensor.broadcast_to
- torch.Tensor.byte
- torch.Tensor.cauchy_
- torch.Tensor.ccol_indices
- torch.Tensor.cdouble
- torch.Tensor.ceil
- torch.Tensor.ceil_
- torch.Tensor.cfloat
- torch.Tensor.chalf
- torch.Tensor.char
- torch.Tensor.cholesky
- torch.Tensor.cholesky_inverse
- torch.Tensor.cholesky_solve
- torch.Tensor.chunk
- torch.Tensor.clamp
- torch.Tensor.clamp_
- torch.Tensor.clip
- torch.Tensor.clip_
- torch.Tensor.clone
- torch.Tensor.coalesce
- torch.Tensor.col_indices
- torch.Tensor.conj
- torch.Tensor.conj_physical
- torch.Tensor.conj_physical_
- torch.Tensor.contiguous
- torch.Tensor.copy_
- torch.Tensor.copysign
- torch.Tensor.copysign_
- torch.Tensor.corrcoef
- torch.Tensor.cos
- torch.Tensor.cos_
- torch.Tensor.cosh
- torch.Tensor.cosh_
- torch.Tensor.count_nonzero
- torch.Tensor.cov
- torch.Tensor.cpu
- torch.Tensor.cross
- torch.Tensor.crow_indices
- torch.Tensor.cuda
- torch.Tensor.cummax
- torch.Tensor.cummin
- torch.Tensor.cumprod
- torch.Tensor.cumprod_
- torch.Tensor.cumsum
- torch.Tensor.cumsum_
- torch.Tensor.data_ptr
- torch.Tensor.deg2rad
- torch.Tensor.dense_dim
- torch.Tensor.dequantize
- torch.Tensor.det
- torch.Tensor.detach
- torch.Tensor.detach_
- torch.Tensor.device
- torch.Tensor.diag
- torch.Tensor.diag_embed
- torch.Tensor.diagflat
- torch.Tensor.diagonal
- torch.Tensor.diagonal_scatter
- torch.Tensor.diff
- torch.Tensor.digamma
- torch.Tensor.digamma_
- torch.Tensor.dim
- torch.Tensor.dim_order
- torch.Tensor.dist
- torch.Tensor.div
- torch.Tensor.div_
- torch.Tensor.divide
- torch.Tensor.divide_
- torch.Tensor.dot
- torch.Tensor.double
- torch.Tensor.dsplit
- torch.Tensor.element_size
- torch.Tensor.eq
- torch.Tensor.eq_
- torch.Tensor.equal
- torch.Tensor.erf
- torch.Tensor.erf_
- torch.Tensor.erfc
- torch.Tensor.erfc_
- torch.Tensor.erfinv
- torch.Tensor.erfinv_
- torch.Tensor.exp
- torch.Tensor.exp_
- torch.Tensor.expand
- torch.Tensor.expand_as
- torch.Tensor.expm1
- torch.Tensor.expm1_
- torch.Tensor.exponential_
- torch.Tensor.fill_
- torch.Tensor.fill_diagonal_
- torch.Tensor.fix
- torch.Tensor.fix_
- torch.Tensor.flatten
- torch.Tensor.flip
- torch.Tensor.fliplr
- torch.Tensor.flipud
- torch.Tensor.float
- torch.Tensor.float_power
- torch.Tensor.float_power_
- torch.Tensor.floor
- torch.Tensor.floor_
- torch.Tensor.floor_divide
- torch.Tensor.floor_divide_
- torch.Tensor.fmax
- torch.Tensor.fmin
- torch.Tensor.fmod
- torch.Tensor.fmod_
- torch.Tensor.frac
- torch.Tensor.frac_
- torch.Tensor.frexp
- torch.Tensor.gather
- torch.Tensor.gcd
- torch.Tensor.gcd_
- torch.Tensor.ge
- torch.Tensor.ge_
- torch.Tensor.geometric_
- torch.Tensor.geqrf
- torch.Tensor.ger
- torch.Tensor.get_device
- torch.Tensor.grad
- torch.Tensor.greater
- torch.Tensor.greater_
- torch.Tensor.greater_equal
- torch.Tensor.greater_equal_
- torch.Tensor.gt
- torch.Tensor.gt_
- torch.Tensor.half
- torch.Tensor.hardshrink
- torch.Tensor.heaviside
- torch.Tensor.histc
- torch.Tensor.histogram
- torch.Tensor.hsplit
- torch.Tensor.hypot
- torch.Tensor.hypot_
- torch.Tensor.i0
- torch.Tensor.i0_
- torch.Tensor.igamma
- torch.Tensor.igamma_
- torch.Tensor.igammac
- torch.Tensor.igammac_
- torch.Tensor.imag
- torch.Tensor.index_add
- torch.Tensor.index_add_
- torch.Tensor.index_copy
- torch.Tensor.index_copy_
- torch.Tensor.index_fill
- torch.Tensor.index_fill_
- torch.Tensor.index_put
- torch.Tensor.index_put_
- torch.Tensor.index_reduce
- torch.Tensor.index_reduce_
- torch.Tensor.index_select
- torch.Tensor.indices
- torch.Tensor.inner
- torch.Tensor.int
- torch.Tensor.int_repr
- torch.Tensor.inverse
- torch.Tensor.is_coalesced
- torch.Tensor.is_complex
- torch.Tensor.is_conj
- torch.Tensor.is_contiguous
- torch.Tensor.is_cuda
- torch.Tensor.is_floating_point
- torch.Tensor.is_inference
- torch.Tensor.is_leaf
- torch.Tensor.is_meta
- torch.Tensor.is_pinned
- torch.Tensor.is_quantized
- torch.Tensor.is_set_to
- torch.Tensor.is_shared
- torch.Tensor.is_signed
- torch.Tensor.is_sparse
- torch.Tensor.is_sparse_csr
- torch.Tensor.isclose
- torch.Tensor.isfinite
- torch.Tensor.isinf
- torch.Tensor.isnan
- torch.Tensor.isneginf
- torch.Tensor.isposinf
- torch.Tensor.isreal
- torch.Tensor.istft
- torch.Tensor.item
- torch.Tensor.itemsize
- torch.Tensor.kthvalue
- torch.Tensor.lcm
- torch.Tensor.lcm_
- torch.Tensor.ldexp
- torch.Tensor.ldexp_
- torch.Tensor.le
- torch.Tensor.le_
- torch.Tensor.lerp
- torch.Tensor.lerp_
- torch.Tensor.less
- torch.Tensor.less_
- torch.Tensor.less_equal
- torch.Tensor.less_equal_
- torch.Tensor.lgamma
- torch.Tensor.lgamma_
- torch.Tensor.log
- torch.Tensor.log10
- torch.Tensor.log10_
- torch.Tensor.log1p
- torch.Tensor.log1p_
- torch.Tensor.log2
- torch.Tensor.log2_
- torch.Tensor.log_
- torch.Tensor.log_normal_
- torch.Tensor.logaddexp
- torch.Tensor.logaddexp2
- torch.Tensor.logcumsumexp
- torch.Tensor.logdet
- torch.Tensor.logical_and
- torch.Tensor.logical_and_
- torch.Tensor.logical_not
- torch.Tensor.logical_not_
- torch.Tensor.logical_or
- torch.Tensor.logical_or_
- torch.Tensor.logical_xor
- torch.Tensor.logical_xor_
- torch.Tensor.logit
- torch.Tensor.logit_
- torch.Tensor.logsumexp
- torch.Tensor.long
- torch.Tensor.lt
- torch.Tensor.lt_
- torch.Tensor.lu
- torch.Tensor.lu_solve
- torch.Tensor.map_
- torch.Tensor.masked_fill
- torch.Tensor.masked_fill_
- torch.Tensor.masked_scatter
- torch.Tensor.masked_scatter_
- torch.Tensor.masked_select
- torch.Tensor.matmul
- torch.Tensor.matrix_exp
- torch.Tensor.matrix_power
- torch.Tensor.max
- torch.Tensor.maximum
- torch.Tensor.mean
- torch.Tensor.median
- torch.Tensor.min
- torch.Tensor.minimum
- torch.Tensor.mm
- torch.Tensor.mode
- torch.Tensor.module_load
- torch.Tensor.moveaxis
- torch.Tensor.movedim
- torch.Tensor.msort
- torch.Tensor.mul
- torch.Tensor.mul_
- torch.Tensor.multinomial
- torch.Tensor.multiply
- torch.Tensor.multiply_
- torch.Tensor.mv
- torch.Tensor.mvlgamma
- torch.Tensor.mvlgamma_
- torch.Tensor.nan_to_num
- torch.Tensor.nan_to_num_
- torch.Tensor.nanmean
- torch.Tensor.nanmedian
- torch.Tensor.nanquantile
- torch.Tensor.nansum
- torch.Tensor.narrow
- torch.Tensor.narrow_copy
- torch.Tensor.nbytes
- torch.Tensor.ndim
- torch.Tensor.ndimension
- torch.Tensor.ne
- torch.Tensor.ne_
- torch.Tensor.neg
- torch.Tensor.neg_
- torch.Tensor.negative
- torch.Tensor.negative_
- torch.Tensor.nelement
- torch.Tensor.new_empty
- torch.Tensor.new_full
- torch.Tensor.new_ones
- torch.Tensor.new_tensor
- torch.Tensor.new_zeros
- torch.Tensor.nextafter
- torch.Tensor.nextafter_
- torch.Tensor.nonzero
- torch.Tensor.norm
- torch.Tensor.normal_
- torch.Tensor.not_equal
- torch.Tensor.not_equal_
- torch.Tensor.numel
- torch.Tensor.numpy
- torch.Tensor.orgqr
- torch.Tensor.ormqr
- torch.Tensor.outer
- torch.Tensor.permute
- torch.Tensor.pin_memory
- torch.Tensor.pinverse
- torch.Tensor.polygamma
- torch.Tensor.polygamma_
- torch.Tensor.positive
- torch.Tensor.pow
- torch.Tensor.pow_
- torch.Tensor.prod
- torch.Tensor.put_
- torch.Tensor.q_per_channel_axis
- torch.Tensor.q_per_channel_scales
- torch.Tensor.q_per_channel_zero_points
- torch.Tensor.q_scale
- torch.Tensor.q_zero_point
- torch.Tensor.qr
- torch.Tensor.qscheme
- torch.Tensor.quantile
- torch.Tensor.rad2deg
- torch.Tensor.random_
- torch.Tensor.ravel
- torch.Tensor.real
- torch.Tensor.reciprocal
- torch.Tensor.reciprocal_
- torch.Tensor.record_stream
- torch.Tensor.register_hook
- torch.Tensor.register_post_accumulate_grad_hook
- torch.Tensor.remainder
- torch.Tensor.remainder_
- torch.Tensor.renorm
- torch.Tensor.renorm_
- torch.Tensor.repeat
- torch.Tensor.repeat_interleave
- torch.Tensor.requires_grad
- torch.Tensor.requires_grad_
- torch.Tensor.reshape
- torch.Tensor.reshape_as
- torch.Tensor.resize_
- torch.Tensor.resize_as_
- torch.Tensor.resolve_conj
- torch.Tensor.resolve_neg
- torch.Tensor.retain_grad
- torch.Tensor.retains_grad
- torch.Tensor.roll
- torch.Tensor.rot90
- torch.Tensor.round
- torch.Tensor.round_
- torch.Tensor.row_indices
- torch.Tensor.rsqrt
- torch.Tensor.rsqrt_
- torch.Tensor.scatter
- torch.Tensor.scatter_
- torch.Tensor.scatter_add
- torch.Tensor.scatter_add_
- torch.Tensor.scatter_reduce
- torch.Tensor.scatter_reduce_
- torch.Tensor.select
- torch.Tensor.select_scatter
- torch.Tensor.set_
- torch.Tensor.sgn
- torch.Tensor.sgn_
- torch.Tensor.shape
- torch.Tensor.share_memory_
- torch.Tensor.short
- torch.Tensor.sigmoid
- torch.Tensor.sigmoid_
- torch.Tensor.sign
- torch.Tensor.sign_
- torch.Tensor.signbit
- torch.Tensor.sin
- torch.Tensor.sin_
- torch.Tensor.sinc
- torch.Tensor.sinc_
- torch.Tensor.sinh
- torch.Tensor.sinh_
- torch.Tensor.size
- torch.Tensor.slice_scatter
- torch.Tensor.slogdet
- torch.Tensor.smm
- torch.Tensor.softmax
- torch.Tensor.sort
- torch.Tensor.sparse_dim
- torch.Tensor.sparse_mask
- torch.Tensor.sparse_resize_
- torch.Tensor.sparse_resize_and_clear_
- torch.Tensor.split
- torch.Tensor.sqrt
- torch.Tensor.sqrt_
- torch.Tensor.square
- torch.Tensor.square_
- torch.Tensor.squeeze
- torch.Tensor.squeeze_
- torch.Tensor.sspaddmm
- torch.Tensor.std
- torch.Tensor.stft
- torch.Tensor.storage
- torch.Tensor.storage_offset
- torch.Tensor.storage_type
- torch.Tensor.stride
- torch.Tensor.sub
- torch.Tensor.sub_
- torch.Tensor.subtract
- torch.Tensor.subtract_
- torch.Tensor.sum
- torch.Tensor.sum_to_size
- torch.Tensor.svd
- torch.Tensor.swapaxes
- torch.Tensor.swapdims
- torch.Tensor.t
- torch.Tensor.t_
- torch.Tensor.take
- torch.Tensor.take_along_dim
- torch.Tensor.tan
- torch.Tensor.tan_
- torch.Tensor.tanh
- torch.Tensor.tanh_
- torch.Tensor.tensor_split
- torch.Tensor.tile
- torch.Tensor.to
- torch.Tensor.to_dense
- torch.Tensor.to_mkldnn
- torch.Tensor.to_sparse
- torch.Tensor.to_sparse_bsc
- torch.Tensor.to_sparse_bsr
- torch.Tensor.to_sparse_coo
- torch.Tensor.to_sparse_csc
- torch.Tensor.to_sparse_csr
- torch.Tensor.tolist
- torch.Tensor.topk
- torch.Tensor.trace
- torch.Tensor.transpose
- torch.Tensor.transpose_
- torch.Tensor.triangular_solve
- torch.Tensor.tril
- torch.Tensor.tril_
- torch.Tensor.triu
- torch.Tensor.triu_
- torch.Tensor.true_divide
- torch.Tensor.true_divide_
- torch.Tensor.trunc
- torch.Tensor.trunc_
- torch.Tensor.type
- torch.Tensor.type_as
- torch.Tensor.unbind
- torch.Tensor.unflatten
- torch.Tensor.unfold
- torch.Tensor.uniform_
- torch.Tensor.unique
- torch.Tensor.unique_consecutive
- torch.Tensor.unsqueeze
- torch.Tensor.unsqueeze_
- torch.Tensor.untyped_storage
- torch.Tensor.values
- torch.Tensor.var
- torch.Tensor.vdot
- torch.Tensor.view
- torch.Tensor.view_as
- torch.Tensor.vsplit
- torch.Tensor.where
- torch.Tensor.xlogy
- torch.Tensor.xlogy_
- torch.Tensor.xpu
- torch.Tensor.zero_
- torch._assert
- torch._dynamo.disallow_in_graph
- torch._foreach_abs
- torch._foreach_abs_
- torch._foreach_acos
- torch._foreach_acos_
- torch._foreach_asin
- torch._foreach_asin_
- torch._foreach_atan
- torch._foreach_atan_
- torch._foreach_ceil
- torch._foreach_ceil_
- torch._foreach_cos
- torch._foreach_cos_
- torch._foreach_cosh
- torch._foreach_cosh_
- torch._foreach_erf
- torch._foreach_erf_
- torch._foreach_erfc
- torch._foreach_erfc_
- torch._foreach_exp
- torch._foreach_exp_
- torch._foreach_expm1
- torch._foreach_expm1_
- torch._foreach_floor
- torch._foreach_floor_
- torch._foreach_frac
- torch._foreach_frac_
- torch._foreach_lgamma
- torch._foreach_lgamma_
- torch._foreach_log
- torch._foreach_log10
- torch._foreach_log10_
- torch._foreach_log1p
- torch._foreach_log1p_
- torch._foreach_log2
- torch._foreach_log2_
- torch._foreach_log_
- torch._foreach_neg
- torch._foreach_neg_
- torch._foreach_reciprocal
- torch._foreach_reciprocal_
- torch._foreach_round
- torch._foreach_round_
- torch._foreach_sigmoid
- torch._foreach_sigmoid_
- torch._foreach_sin
- torch._foreach_sin_
- torch._foreach_sinh
- torch._foreach_sinh_
- torch._foreach_sqrt
- torch._foreach_sqrt_
- torch._foreach_tan
- torch._foreach_tan_
- torch._foreach_trunc
- torch._foreach_trunc_
- torch._foreach_zero_
- torch._logging
- torch._logging.set_logs
- torch.abs
- torch.absolute
- torch.acos
- torch.acosh
- torch.add
- torch.addbmm
- torch.addcdiv
- torch.addcmul
- torch.addmm
- torch.addmv
- torch.addr
- torch.adjoint
- torch.all
- torch.allclose
- torch.amax
- torch.amin
- torch.aminmax
- torch.angle
- torch.any
- torch.ao.nn.quantizable
- torch.ao.ns._numeric_suite
- torch.ao.ns._numeric_suite_fx
- torch.ao.ns.fx.utils
- torch.ao.quantization
- torch.ao.quantization.backend_config
- torch.ao.quantization.fake_quantize
- torch.ao.quantization.fx.custom_config
- torch.ao.quantization.observer
- torch.ao.quantization.pt2e.export_utils
- torch.ao.quantization.qconfig
- torch.ao.quantization.qconfig_mapping
- torch.ao.quantization.quantize_fx
- torch.arange
- torch.arccos
- torch.arccosh
- torch.arcsin
- torch.arcsinh
- torch.arctan
- torch.arctan2
- torch.arctanh
- torch.are_deterministic_algorithms_enabled
- torch.argmax
- torch.argmin
- torch.argsort
- torch.argwhere
- torch.as_strided
- torch.as_tensor
- torch.asarray
- torch.asin
- torch.asinh
- torch.atan
- torch.atan2
- torch.atanh
- torch.atleast_1d
- torch.atleast_2d
- torch.atleast_3d
- torch.autograd APIs
- torch.autograd.Function.backward
- torch.autograd.Function.forward
- torch.autograd.Function.jvp
- torch.autograd.Function.vmap
- torch.autograd.Functions
- torch.autograd.backward
- torch.autograd.forward_ad.enter_dual_level
- torch.autograd.forward_ad.exit_dual_level
- torch.autograd.forward_ad.make_dual
- torch.autograd.forward_ad.unpack_dual
- torch.autograd.function.FunctionCtx.mark_dirty
- torch.autograd.function.FunctionCtx.mark_non_differentiable
- torch.autograd.function.FunctionCtx.save_for_backward
- torch.autograd.function.FunctionCtx.set_materialize_grads
- torch.autograd.function.once_differentiable
- torch.autograd.functional.hessian
- torch.autograd.functional.hvp
- torch.autograd.functional.jacobian
- torch.autograd.functional.jvp
- torch.autograd.functional.vhp
- torch.autograd.functional.vjp
- torch.autograd.grad
- torch.autograd.gradcheck.GradcheckError
- torch.autograd.gradcheck.gradcheck
- torch.autograd.gradcheck.gradgradcheck
- torch.autograd.graph.Node.metadata
- torch.autograd.graph.Node.name
- torch.autograd.graph.Node.next_functions
- torch.autograd.graph.Node.register_hook
- torch.autograd.graph.Node.register_prehook
- torch.autograd.graph.increment_version
- torch.autograd.profiler.load_nvprof
- torch.autograd.profiler.parse_nvprof_trace
- torch.autograd.profiler.profile.export_chrome_trace
- torch.autograd.profiler.profile.key_averages
- torch.autograd.profiler.profile.self_cpu_time_total
- torch.autograd.profiler.profile.total_average
- torch.baddbmm
- torch.bartlett_window
- torch.bernoulli
- torch.bincount
- torch.bitwise_and
- torch.bitwise_left_shift
- torch.bitwise_not
- torch.bitwise_or
- torch.bitwise_right_shift
- torch.bitwise_xor
- torch.blackman_window
- torch.block_diag
- torch.bmm
- torch.broadcast_shapes
- torch.broadcast_tensors
- torch.broadcast_to
- torch.bucketize
- torch.can_cast
- torch.cartesian_prod
- torch.cat
- torch.cdist
- torch.ceil
- torch.chain_matmul
- torch.cholesky
- torch.cholesky_inverse
- torch.cholesky_solve
- torch.chunk
- torch.clamp
- torch.clip
- torch.clone
- torch.column_stack
- torch.combinations
- torch.compile
- torch.compiled_with_cxx11_abi
- torch.compiler
- torch.compiler
- torch.compiler API reference
- torch.compiler API reference
- torch.compiler.allow_in_graph
- torch.compiler.allow_in_graph
- torch.compiler.assume_constant_result
- torch.compiler.compile
- torch.compiler.cudagraph_mark_step_begin
- torch.compiler.disable
- torch.compiler.disable
- torch.compiler.is_compiling
- torch.compiler.is_dynamo_compiling
- torch.compiler.list_backends
- torch.compiler.reset
- torch.complex
- torch.concat
- torch.concatenate
- torch.cond
- torch.cond
- torch.conj
- torch.conj_physical
- torch.copysign
- torch.corrcoef
- torch.cos
- torch.cosh
- torch.count_nonzero
- torch.cov
- torch.cpu.current_device
- torch.cpu.current_stream
- torch.cpu.device_count
- torch.cpu.is_available
- torch.cpu.set_device
- torch.cpu.stream
- torch.cpu.synchronize
- torch.cross
- torch.cuda.OutOfMemoryError
- torch.cuda.caching_allocator_alloc
- torch.cuda.caching_allocator_delete
- torch.cuda.can_device_access_peer
- torch.cuda.change_current_allocator
- torch.cuda.clock_rate
- torch.cuda.comm.broadcast
- torch.cuda.comm.broadcast_coalesced
- torch.cuda.comm.gather
- torch.cuda.comm.reduce_add
- torch.cuda.comm.scatter
- torch.cuda.current_blas_handle
- torch.cuda.current_device
- torch.cuda.current_stream
- torch.cuda.default_stream
- torch.cuda.device_count
- torch.cuda.empty_cache
- torch.cuda.get_allocator_backend
- torch.cuda.get_arch_list
- torch.cuda.get_device_capability
- torch.cuda.get_device_name
- torch.cuda.get_device_properties
- torch.cuda.get_gencode_flags
- torch.cuda.get_rng_state
- torch.cuda.get_rng_state_all
- torch.cuda.get_sync_debug_mode
- torch.cuda.graph_pool_handle
- torch.cuda.init
- torch.cuda.initial_seed
- torch.cuda.ipc_collect
- torch.cuda.is_available
- torch.cuda.is_current_stream_capturing
- torch.cuda.is_initialized
- torch.cuda.jiterator._create_jit_fn
- torch.cuda.jiterator._create_multi_output_jit_fn
- torch.cuda.list_gpu_processes
- torch.cuda.make_graphed_callables
- torch.cuda.manual_seed
- torch.cuda.manual_seed_all
- torch.cuda.max_memory_allocated
- torch.cuda.max_memory_cached
- torch.cuda.max_memory_reserved
- torch.cuda.mem_get_info
- torch.cuda.memory_allocated
- torch.cuda.memory_cached
- torch.cuda.memory_reserved
- torch.cuda.memory_snapshot
- torch.cuda.memory_stats
- torch.cuda.memory_summary
- torch.cuda.memory_usage
- torch.cuda.nvtx.mark
- torch.cuda.nvtx.range
- torch.cuda.nvtx.range_pop
- torch.cuda.nvtx.range_push
- torch.cuda.power_draw
- torch.cuda.reset_max_memory_allocated
- torch.cuda.reset_max_memory_cached
- torch.cuda.reset_peak_memory_stats
- torch.cuda.seed
- torch.cuda.seed_all
- torch.cuda.set_device
- torch.cuda.set_per_process_memory_fraction
- torch.cuda.set_rng_state
- torch.cuda.set_rng_state_all
- torch.cuda.set_stream
- torch.cuda.set_sync_debug_mode
- torch.cuda.stream
- torch.cuda.synchronize
- torch.cuda.temperature
- torch.cuda.utilization
- torch.cummax
- torch.cummin
- torch.cumprod
- torch.cumsum
- torch.cumulative_trapezoid
- torch.deg2rad
- torch.dequantize
- torch.det
- torch.device
- torch.device
- torch.diag
- torch.diag_embed
- torch.diagflat
- torch.diagonal
- torch.diagonal_scatter
- torch.diff
- torch.digamma
- torch.dist
- torch.distributed backends
- torch.div
- torch.div performing integer division
- torch.divide
- torch.dot
- torch.dsplit
- torch.dstack
- torch.dtype
- torch.dtype
- torch.dynamic-shape
- torch.dynamic-value
- torch.einsum
- torch.empty
- torch.empty_like
- torch.empty_strided
- torch.eq
- torch.equal
- torch.erf
- torch.erfc
- torch.erfinv
- torch.escape-hatch
- torch.exp
- torch.exp2
- torch.expm1
- torch.export
- torch.export IR Specification
- torch.export IR Specification
- torch.eye
- torch.fake_quantize_per_channel_affine
- torch.fake_quantize_per_tensor_affine
- torch.fft
- torch.fft.fft
- torch.fft.fft2
- torch.fft.fftfreq
- torch.fft.fftn
- torch.fft.fftshift
- torch.fft.hfft
- torch.fft.hfft2
- torch.fft.hfftn
- torch.fft.ifft
- torch.fft.ifft2
- torch.fft.ifftn
- torch.fft.ifftshift
- torch.fft.ihfft
- torch.fft.ihfft2
- torch.fft.ihfftn
- torch.fft.irfft
- torch.fft.irfft2
- torch.fft.irfftn
- torch.fft.rfft
- torch.fft.rfft2
- torch.fft.rfftfreq
- torch.fft.rfftn
- torch.finfo
- torch.finfo
- torch.fix
- torch.flatten
- torch.flip
- torch.fliplr
- torch.flipud
- torch.float_power
- torch.floor
- torch.floor_divide
- torch.fmax
- torch.fmin
- torch.fmod
- torch.frac
- torch.frexp
- torch.from_dlpack
- torch.from_file
- torch.from_numpy
- torch.frombuffer
- torch.full
- torch.full always inferring a float dtype
- torch.full_like
- torch.func
- torch.func Whirlwind Tour
- torch.func transforms and/or torch.vmap()
- torch.func.functional_call
- torch.func.functionalize
- torch.func.grad
- torch.func.grad_and_value
- torch.func.hessian
- torch.func.jacfwd
- torch.func.jacrev
- torch.func.jvp
- torch.func.jvp() Support
- torch.func.linearize
- torch.func.replace_all_batch_norm_modules_
- torch.func.stack_module_state
- torch.func.vjp
- torch.func.vmap
- torch.futures
- torch.futures
- torch.fx
- torch.fx.experimental
- torch.fx.experimental.symbolic_shapes.canonicalize_bool_expr
- torch.fx.experimental.symbolic_shapes.check_consistent
- torch.fx.experimental.symbolic_shapes.compute_unbacked_bindings
- torch.fx.experimental.symbolic_shapes.constrain_range
- torch.fx.experimental.symbolic_shapes.constrain_unify
- torch.fx.experimental.symbolic_shapes.definitely_false
- torch.fx.experimental.symbolic_shapes.definitely_true
- torch.fx.experimental.symbolic_shapes.guard_size_oblivious
- torch.fx.experimental.symbolic_shapes.has_free_symbols
- torch.fx.experimental.symbolic_shapes.hint_int
- torch.fx.experimental.symbolic_shapes.is_concrete_bool
- torch.fx.experimental.symbolic_shapes.is_concrete_int
- torch.fx.experimental.symbolic_shapes.lru_cache
- torch.fx.experimental.symbolic_shapes.parallel_and
- torch.fx.experimental.symbolic_shapes.parallel_or
- torch.fx.experimental.symbolic_shapes.rebind_unbacked
- torch.fx.experimental.symbolic_shapes.resolve_unbacked_bindings
- torch.fx.experimental.symbolic_shapes.statically_known_true
- torch.fx.experimental.symbolic_shapes.sym_eq
- torch.gather
- torch.gcd
- torch.ge
- torch.geqrf
- torch.ger
- torch.get_default_device
- torch.get_default_dtype
- torch.get_deterministic_debug_mode
- torch.get_device_module
- torch.get_float32_matmul_precision
- torch.get_num_interop_threads
- torch.get_num_threads
- torch.get_rng_state
- torch.gradient
- torch.greater
- torch.greater_equal
- torch.gt
- torch.hamming_window
- torch.hann_window
- torch.heaviside
- torch.histc
- torch.histogram
- torch.histogramdd
- torch.hsplit
- torch.hspmm
- torch.hstack
- torch.hub
- torch.hypot
- torch.i0
- torch.igamma
- torch.igammac
- torch.iinfo
- torch.iinfo
- torch.imag
- torch.index_add
- torch.index_copy
- torch.index_reduce
- torch.index_select
- torch.initial_seed
- torch.inner
- torch.inverse
- torch.is_complex
- torch.is_conj
- torch.is_deterministic_algorithms_warn_only_enabled
- torch.is_floating_point
- torch.is_grad_enabled
- torch.is_inference_mode_enabled
- torch.is_nonzero
- torch.is_storage
- torch.is_tensor
- torch.is_warn_always_enabled
- torch.isclose
- torch.isfinite
- torch.isin
- torch.isinf
- torch.isnan
- torch.isneginf
- torch.isposinf
- torch.isreal
- torch.istft
- torch.jit.annotate
- torch.jit.annotate(T, expr)
- torch.jit.enable_onednn_fusion
- torch.jit.fork
- torch.jit.freeze
- torch.jit.ignore
- torch.jit.interface
- torch.jit.isinstance
- torch.jit.load
- torch.jit.onednn_fusion_enabled
- torch.jit.optimize_for_inference
- torch.jit.save
- torch.jit.script
- torch.jit.script_if_tracing
- torch.jit.set_fusion_strategy
- torch.jit.trace
- torch.jit.trace_module
- torch.jit.unused
- torch.jit.wait
- torch.kaiser_window
- torch.kron
- torch.kthvalue
- torch.layout
- torch.layout
- torch.lcm
- torch.ldexp
- torch.le
- torch.lerp
- torch.less
- torch.less_equal
- torch.lgamma
- torch.library
- torch.linalg
- torch.linalg.cholesky
- torch.linalg.cholesky_ex
- torch.linalg.cond
- torch.linalg.cross
- torch.linalg.det
- torch.linalg.diagonal
- torch.linalg.eig
- torch.linalg.eigh
- torch.linalg.eigvals
- torch.linalg.eigvalsh
- torch.linalg.householder_product
- torch.linalg.inv
- torch.linalg.inv_ex
- torch.linalg.ldl_factor
- torch.linalg.ldl_factor_ex
- torch.linalg.ldl_solve
- torch.linalg.lstsq
- torch.linalg.lu
- torch.linalg.lu_factor
- torch.linalg.lu_factor_ex
- torch.linalg.lu_solve
- torch.linalg.matmul
- torch.linalg.matrix_exp
- torch.linalg.matrix_norm
- torch.linalg.matrix_power
- torch.linalg.matrix_rank
- torch.linalg.multi_dot
- torch.linalg.norm
- torch.linalg.pinv
- torch.linalg.qr
- torch.linalg.slogdet
- torch.linalg.solve
- torch.linalg.solve_ex
- torch.linalg.solve_triangular
- torch.linalg.svd
- torch.linalg.svdvals
- torch.linalg.tensorinv
- torch.linalg.tensorsolve
- torch.linalg.vander
- torch.linalg.vecdot
- torch.linalg.vector_norm
- torch.linspace
- torch.load
- torch.lobpcg
- torch.log
- torch.log10
- torch.log1p
- torch.log2
- torch.logaddexp
- torch.logaddexp2
- torch.logcumsumexp
- torch.logdet
- torch.logical_and
- torch.logical_not
- torch.logical_or
- torch.logical_xor
- torch.logit
- torch.logspace
- torch.logsumexp
- torch.lt
- torch.lu
- torch.lu_solve
- torch.lu_unpack
- torch.manual_seed
- torch.map
- torch.masked
- torch.masked
- torch.masked_select
- torch.matmul
- torch.matrix_exp
- torch.matrix_power
- torch.max
- torch.maximum
- torch.mean
- torch.median
- torch.memory_format
- torch.meshgrid
- torch.min
- torch.minimum
- torch.mm
- torch.mode
- torch.monitor
- torch.moveaxis
- torch.movedim
- torch.mps.current_allocated_memory
- torch.mps.device_count
- torch.mps.driver_allocated_memory
- torch.mps.empty_cache
- torch.mps.get_rng_state
- torch.mps.manual_seed
- torch.mps.profiler.profile
- torch.mps.profiler.start
- torch.mps.profiler.stop
- torch.mps.seed
- torch.mps.set_per_process_memory_fraction
- torch.mps.set_rng_state
- torch.mps.synchronize
- torch.msort
- torch.mtia
- torch.mtia.DeferredMtiaCallError
- torch.mtia.current_device
- torch.mtia.current_stream
- torch.mtia.default_stream
- torch.mtia.device_count
- torch.mtia.init
- torch.mtia.is_available
- torch.mtia.is_initialized
- torch.mtia.set_stream
- torch.mtia.stream
- torch.mtia.synchronize
- torch.mul
- torch.multinomial
- torch.multiply
- torch.mutation
- torch.mv
- torch.mvlgamma
- torch.nan_to_num
- torch.nanmean
- torch.nanmedian
- torch.nanquantile
- torch.nansum
- torch.narrow
- torch.narrow_copy
- torch.ne
- torch.neg
- torch.negative
- torch.nextafter
- torch.nn.attention.bias.CausalBias
- torch.nn.attention.bias.causal_lower_right
- torch.nn.attention.bias.causal_upper_left
- torch.nn.attention.sdpa_kernel
- torch.nn.functional
- torch.nn.functional.adaptive_avg_pool1d
- torch.nn.functional.adaptive_avg_pool2d
- torch.nn.functional.adaptive_avg_pool3d
- torch.nn.functional.adaptive_max_pool1d
- torch.nn.functional.adaptive_max_pool2d
- torch.nn.functional.adaptive_max_pool3d
- torch.nn.functional.affine_grid
- torch.nn.functional.alpha_dropout
- torch.nn.functional.avg_pool1d
- torch.nn.functional.avg_pool2d
- torch.nn.functional.avg_pool3d
- torch.nn.functional.batch_norm
- torch.nn.functional.bilinear
- torch.nn.functional.binary_cross_entropy
- torch.nn.functional.binary_cross_entropy_with_logits
- torch.nn.functional.celu
- torch.nn.functional.conv1d
- torch.nn.functional.conv2d
- torch.nn.functional.conv3d
- torch.nn.functional.conv_transpose1d
- torch.nn.functional.conv_transpose2d
- torch.nn.functional.conv_transpose3d
- torch.nn.functional.cosine_embedding_loss
- torch.nn.functional.cosine_similarity
- torch.nn.functional.cross_entropy
- torch.nn.functional.ctc_loss
- torch.nn.functional.dropout
- torch.nn.functional.dropout1d
- torch.nn.functional.dropout2d
- torch.nn.functional.dropout3d
- torch.nn.functional.elu
- torch.nn.functional.elu_
- torch.nn.functional.embedding
- torch.nn.functional.embedding_bag
- torch.nn.functional.feature_alpha_dropout
- torch.nn.functional.fold
- torch.nn.functional.fractional_max_pool2d
- torch.nn.functional.fractional_max_pool3d
- torch.nn.functional.gaussian_nll_loss
- torch.nn.functional.gelu
- torch.nn.functional.glu
- torch.nn.functional.grid_sample
- torch.nn.functional.group_norm
- torch.nn.functional.gumbel_softmax
- torch.nn.functional.hardshrink
- torch.nn.functional.hardsigmoid
- torch.nn.functional.hardswish
- torch.nn.functional.hardtanh
- torch.nn.functional.hardtanh_
- torch.nn.functional.hinge_embedding_loss
- torch.nn.functional.huber_loss
- torch.nn.functional.instance_norm
- torch.nn.functional.interpolate
- torch.nn.functional.kl_div
- torch.nn.functional.l1_loss
- torch.nn.functional.layer_norm
- torch.nn.functional.leaky_relu
- torch.nn.functional.leaky_relu_
- torch.nn.functional.linear
- torch.nn.functional.local_response_norm
- torch.nn.functional.log_softmax
- torch.nn.functional.logsigmoid
- torch.nn.functional.lp_pool1d
- torch.nn.functional.lp_pool2d
- torch.nn.functional.lp_pool3d
- torch.nn.functional.margin_ranking_loss
- torch.nn.functional.max_pool1d
- torch.nn.functional.max_pool2d
- torch.nn.functional.max_pool3d
- torch.nn.functional.max_unpool1d
- torch.nn.functional.max_unpool2d
- torch.nn.functional.max_unpool3d
- torch.nn.functional.mish
- torch.nn.functional.mse_loss
- torch.nn.functional.multi_margin_loss
- torch.nn.functional.multilabel_margin_loss
- torch.nn.functional.multilabel_soft_margin_loss
- torch.nn.functional.nll_loss
- torch.nn.functional.normalize
- torch.nn.functional.one_hot
- torch.nn.functional.pad
- torch.nn.functional.pairwise_distance
- torch.nn.functional.pdist
- torch.nn.functional.pixel_shuffle
- torch.nn.functional.pixel_unshuffle
- torch.nn.functional.poisson_nll_loss
- torch.nn.functional.prelu
- torch.nn.functional.relu
- torch.nn.functional.relu6
- torch.nn.functional.relu_
- torch.nn.functional.rms_norm
- torch.nn.functional.rrelu
- torch.nn.functional.rrelu_
- torch.nn.functional.scaled_dot_product_attention
- torch.nn.functional.selu
- torch.nn.functional.sigmoid
- torch.nn.functional.silu
- torch.nn.functional.smooth_l1_loss
- torch.nn.functional.soft_margin_loss
- torch.nn.functional.softmax
- torch.nn.functional.softmin
- torch.nn.functional.softplus
- torch.nn.functional.softshrink
- torch.nn.functional.softsign
- torch.nn.functional.tanh
- torch.nn.functional.tanhshrink
- torch.nn.functional.threshold
- torch.nn.functional.threshold_
- torch.nn.functional.torch.nn.parallel.data_parallel
- torch.nn.functional.triplet_margin_loss
- torch.nn.functional.triplet_margin_with_distance_loss
- torch.nn.functional.unfold
- torch.nn.functional.upsample
- torch.nn.functional.upsample_bilinear
- torch.nn.functional.upsample_nearest
- torch.nn.init
- torch.nn.init
- torch.nn.modules.module.register_module_backward_hook
- torch.nn.modules.module.register_module_buffer_registration_hook
- torch.nn.modules.module.register_module_forward_hook
- torch.nn.modules.module.register_module_forward_pre_hook
- torch.nn.modules.module.register_module_full_backward_hook
- torch.nn.modules.module.register_module_full_backward_pre_hook
- torch.nn.modules.module.register_module_module_registration_hook
- torch.nn.modules.module.register_module_parameter_registration_hook
- torch.nn.utils.clip_grad_norm
- torch.nn.utils.clip_grad_norm_
- torch.nn.utils.clip_grad_value_
- torch.nn.utils.convert_conv2d_weight_memory_format
- torch.nn.utils.convert_conv3d_weight_memory_format
- torch.nn.utils.fuse_conv_bn_eval
- torch.nn.utils.fuse_conv_bn_weights
- torch.nn.utils.fuse_linear_bn_eval
- torch.nn.utils.fuse_linear_bn_weights
- torch.nn.utils.parameters_to_vector
- torch.nn.utils.parametrizations.orthogonal
- torch.nn.utils.parametrizations.spectral_norm
- torch.nn.utils.parametrizations.weight_norm
- torch.nn.utils.parametrize.cached
- torch.nn.utils.parametrize.is_parametrized
- torch.nn.utils.parametrize.register_parametrization
- torch.nn.utils.parametrize.remove_parametrizations
- torch.nn.utils.prune.custom_from_mask
- torch.nn.utils.prune.global_unstructured
- torch.nn.utils.prune.identity
- torch.nn.utils.prune.is_pruned
- torch.nn.utils.prune.l1_unstructured
- torch.nn.utils.prune.ln_structured
- torch.nn.utils.prune.random_structured
- torch.nn.utils.prune.random_unstructured
- torch.nn.utils.prune.remove
- torch.nn.utils.remove_spectral_norm
- torch.nn.utils.remove_weight_norm
- torch.nn.utils.rnn.pack_padded_sequence
- torch.nn.utils.rnn.pack_sequence
- torch.nn.utils.rnn.pad_packed_sequence
- torch.nn.utils.rnn.pad_sequence
- torch.nn.utils.rnn.unpack_sequence
- torch.nn.utils.rnn.unpad_sequence
- torch.nn.utils.skip_init
- torch.nn.utils.spectral_norm
- torch.nn.utils.stateless.functional_call
- torch.nn.utils.vector_to_parameters
- torch.nn.utils.weight_norm
- torch.nonzero
- torch.norm
- torch.normal
- torch.not_equal
- torch.numel
- torch.ones
- torch.ones_like
- torch.onnx
- torch.operator
- torch.optim.Optimizer.add_param_group
- torch.optim.Optimizer.load_state_dict
- torch.optim.Optimizer.state_dict
- torch.optim.Optimizer.step
- torch.optim.Optimizer.zero_grad
- torch.orgqr
- torch.ormqr
- torch.outer
- torch.package
- torch.package Format Overview
- torch.package sharp edges
- torch.pca_lowrank
- torch.permute
- torch.pinverse
- torch.poisson
- torch.polar
- torch.polygamma
- torch.positive
- torch.pow
- torch.prod
- torch.profiler
- torch.promote_types
- torch.qr
- torch.quantile
- torch.quantize_per_channel
- torch.quantize_per_tensor
- torch.quantized_batch_norm
- torch.quantized_max_pool1d
- torch.quantized_max_pool2d
- torch.rad2deg
- torch.rand
- torch.rand_like
- torch.randint
- torch.randint_like
- torch.randn
- torch.randn_like
- torch.randperm
- torch.range
- torch.ravel
- torch.real
- torch.reciprocal
- torch.remainder
- torch.renorm
- torch.repeat_interleave
- torch.reshape
- torch.resolve_conj
- torch.resolve_neg
- torch.result_type
- torch.roll
- torch.rot90
- torch.round
- torch.row_stack
- torch.rsqrt
- torch.save
- torch.scatter
- torch.scatter_add
- torch.scatter_reduce
- torch.searchsorted
- torch.seed
- torch.select
- torch.select_scatter
- torch.set_default_device
- torch.set_default_dtype
- torch.set_default_tensor_type
- torch.set_deterministic_debug_mode
- torch.set_float32_matmul_precision
- torch.set_flush_denormal
- torch.set_num_interop_threads
- torch.set_num_threads
- torch.set_printoptions
- torch.set_rng_state
- torch.set_warn_always
- torch.sgn
- torch.sigmoid
- torch.sign
- torch.signal.windows.bartlett
- torch.signal.windows.blackman
- torch.signal.windows.cosine
- torch.signal.windows.exponential
- torch.signal.windows.gaussian
- torch.signal.windows.general_cosine
- torch.signal.windows.general_hamming
- torch.signal.windows.hamming
- torch.signal.windows.hann
- torch.signal.windows.kaiser
- torch.signal.windows.nuttall
- torch.signbit
- torch.sin
- torch.sinc
- torch.sinh
- torch.slice_scatter
- torch.slogdet
- torch.smm
- torch.softmax
- torch.sort
- torch.sparse
- torch.sparse
- torch.sparse.addmm
- torch.sparse.as_sparse_gradcheck
- torch.sparse.log_softmax
- torch.sparse.mm
- torch.sparse.sampled_addmm
- torch.sparse.softmax
- torch.sparse.spdiags
- torch.sparse.sum
- torch.sparse_bsc_tensor
- torch.sparse_bsr_tensor
- torch.sparse_compressed_tensor
- torch.sparse_coo_tensor
- torch.sparse_csc_tensor
- torch.sparse_csr_tensor
- torch.special
- torch.split
- torch.sqrt
- torch.square
- torch.squeeze
- torch.sspaddmm
- torch.stack
- torch.std
- torch.std_mean
- torch.stft
- torch.sub
- torch.subtract
- torch.sum
- torch.svd
- torch.svd_lowrank
- torch.swapaxes
- torch.swapdims
- torch.sym_float
- torch.sym_int
- torch.sym_ite
- torch.sym_max
- torch.sym_min
- torch.sym_not
- torch.t
- torch.take
- torch.take_along_dim
- torch.tan
- torch.tanh
- torch.tensor
- torch.tensor_split
- torch.tensordot
- torch.tile
- torch.topk
- torch.trace
- torch.transpose
- torch.trapezoid
- torch.trapz
- torch.triangular_solve
- torch.tril
- torch.tril_indices
- torch.triu
- torch.triu_indices
- torch.true_divide
- torch.trunc
- torch.unbind
- torch.unflatten
- torch.unique
- torch.unique_consecutive
- torch.unravel_index
- torch.unsqueeze
- torch.use_deterministic_algorithms
- torch.utils.checkpoint
- torch.utils.cpp_extension
- torch.utils.dlpack
- torch.utils.generate_methods_for_privateuse1_backend
- torch.utils.get_cpp_backtrace
- torch.utils.mobile_optimizer
- torch.utils.model_zoo
- torch.utils.rename_privateuse1_backend
- torch.utils.set_module
- torch.utils.swap_tensors
- torch.vander
- torch.var
- torch.var_mean
- torch.vdot
- torch.view_as_complex
- torch.view_as_real
- torch.vmap
- torch.vmap() Support
- torch.vsplit
- torch.vstack
- torch.where
- torch.xlogy
- torch.xpu.current_device
- torch.xpu.current_stream
- torch.xpu.device_count
- torch.xpu.empty_cache
- torch.xpu.get_device_capability
- torch.xpu.get_device_name
- torch.xpu.get_device_properties
- torch.xpu.get_rng_state
- torch.xpu.get_rng_state_all
- torch.xpu.init
- torch.xpu.initial_seed
- torch.xpu.is_available
- torch.xpu.is_initialized
- torch.xpu.manual_seed
- torch.xpu.manual_seed_all
- torch.xpu.seed
- torch.xpu.seed_all
- torch.xpu.set_device
- torch.xpu.set_rng_state
- torch.xpu.set_rng_state_all
- torch.xpu.set_stream
- torch.xpu.stream
- torch.xpu.synchronize
- torch.zeros
- torch.zeros_like
- torch::deploy has been moved to pytorch/multipy
- torch_sym_min
- torch_sym_min
- torchrun (Elastic Launch)
- type-promotion-doc
- type_reflection_method
- type_reflection_method
- unbind
- update_bn_stats
- upsample
- upsample_bilinear
- upsample_nearest
- user_input_mutation
- user_input_mutation
- vjp() (vector-Jacobian product)
- vmap limitations
- vmap() (auto-vectorization)
- x86 CPU