| 
      T(torch.Tensor 属性)
t()(在 torch 模块中)
      t_()(torch.Tensor 方法)
Tag(torch 中的类)
take()(在 torch 模块中)
      take_along_dim()(在 torch 模块中)
      tan()(在 torch 模块中)
      tan_()(torch.Tensor 方法)
tangent(torch.autograd.forward_ad.UnpackedDualTensor 属性)
Tanh(torch.nn 中的类)
tanh()(在 torch 模块中)
      tanh_()(torch.Tensor 方法)
Tanhshrink(torch.nn 中的类)
tanhshrink()(在 torch.nn.functional 模块中)
TanhTransform(torch.distributions.transforms 中的类)
TCPStore(torch.distributed 中的类)
温度 (torch.distributions.relaxed_bernoulli.RelaxedBernoulli 属性)
      temperature() (在模块 torch.cuda 中)
张量 (torch 中的类)
tensor() (在模块 torch 中)
tensor_split() (在模块 torch 中)
      tensor_storage_size() (torch.distributed.checkpoint.planner.WriteItem 方法)
tensorboard_trace_handler() (在模块 torch.profiler 中)
TensorboardEventHandler (torch.monitor 中的类)
TensorDataset (torch.utils.data 中的类)
tensordot() (在模块 torch 中)
tensorinv() (在模块 torch.linalg 中)
TensorPipeRpcBackendOptions (torch.distributed.rpc 中的类)
tensorsolve() (在模块 torch.linalg 中)
then() (torch.futures.Future 方法)
阈值 (torch.ao.nn.quantized.functional 中的类)
阈值 (torch.nn 中的类)
threshold() (在模块 torch.nn.functional 中)
threshold_() (在模块 torch.nn.functional 中)
tile() (在模块 torch 中)
      timeit() (torch.utils.benchmark.Timer 方法)
计时器 (torch.utils.benchmark 中的类)
TimerClient (torch.distributed.elastic.timer 中的类)
TimerRequest (torch.distributed.elastic.timer 中的类)
TimerServer (torch.distributed.elastic.timer 中的类)
时间戳 (torch.monitor.Event 属性)
to() (torch.jit.ScriptModule 方法)
      to_bool() (torch.fx.Tracer 方法)
to_dense() (torch.Tensor 方法)
to_dict() (torch.ao.quantization.backend_config.BackendConfig 方法)
      to_dlpack() (在模块 torch.utils.dlpack 中)
to_empty() (torch.jit.ScriptModule 方法)
      to_folder() (torch.fx.GraphModule 方法)
to_here() (torch.distributed.rpc.PyRRef 方法)
to_mkldnn() (torch.Tensor 方法)
to_padded_tensor() (在模块 torch.nested 中)
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 中)
      
    torch
      
    torch.__config__
      
    torch.__future__
      
    torch._logging
      
    torch.amp
      
    torch.amp.autocast_mode
      
    torch.amp.grad_scaler
      
    torch.ao
      
    torch.ao.nn
      
    torch.ao.nn.intrinsic
      
    torch.ao.nn.intrinsic.modules
      
    torch.ao.nn.intrinsic.modules.fused
      
    torch.ao.nn.intrinsic.qat
      
    torch.ao.nn.intrinsic.qat.modules
      
    torch.ao.nn.intrinsic.qat.modules.conv_fused
      
    torch.ao.nn.intrinsic.qat.modules.linear_fused
      
    torch.ao.nn.intrinsic.qat.modules.linear_relu
      
    torch.ao.nn.intrinsic.quantized
      
    torch.ao.nn.intrinsic.quantized.dynamic
      
    torch.ao.nn.intrinsic.quantized.dynamic.modules
      
    torch.ao.nn.intrinsic.quantized.dynamic.modules.linear_relu
      
    torch.ao.nn.intrinsic.quantized.modules
      
    torch.ao.nn.intrinsic.quantized.modules.bn_relu
      
    torch.ao.nn.intrinsic.quantized.modules.conv_add
      
    torch.ao.nn.intrinsic.quantized.modules.conv_relu
      
    torch.ao.nn.intrinsic.quantized.modules.linear_relu
      
    torch.ao.nn.qat
      
    torch.ao.nn.qat.dynamic
      
    torch.ao.nn.qat.dynamic.modules
      
    torch.ao.nn.qat.dynamic.modules.linear
      
    torch.ao.nn.qat.modules
      
    torch.ao.nn.qat.modules.conv
      
    torch.ao.nn.qat.modules.embedding_ops
      
    torch.ao.nn.qat.modules.linear
      
    torch.ao.nn.quantizable
      
    torch.ao.nn.quantizable.modules
      
    torch.ao.nn.quantizable.modules.activation
      
    torch.ao.nn.quantizable.modules.rnn
      
    torch.ao.nn.quantized
      
    torch.ao.nn.quantized.dynamic
      
    torch.ao.nn.quantized.dynamic.modules
      
    torch.ao.nn.quantized.dynamic.modules.conv
      
    torch.ao.nn.quantized.dynamic.modules.linear
      
    torch.ao.nn.quantized.dynamic.modules.rnn
      
    torch.ao.nn.quantized.functional
      
    torch.ao.nn.quantized.modules
      
    torch.ao.nn.quantized.modules.activation
      
    torch.ao.nn.quantized.modules.batchnorm
      
    torch.ao.nn.quantized.modules.conv
      
    torch.ao.nn.quantized.modules.dropout
      
    torch.ao.nn.quantized.modules.embedding_ops
      
    torch.ao.nn.quantized.modules.functional_modules
      
    torch.ao.nn.quantized.modules.linear
      
    torch.ao.nn.quantized.modules.normalization
      
    torch.ao.nn.quantized.modules.rnn
      
    torch.ao.nn.quantized.modules.utils
      
    torch.ao.nn.quantized.reference
      
    torch.ao.nn.quantized.reference.modules
      
    torch.ao.nn.quantized.reference.modules.conv
      
    torch.ao.nn.quantized.reference.modules.linear
      
    torch.ao.nn.quantized.reference.modules.rnn
      
    torch.ao.nn.quantized.reference.modules.sparse
      
    torch.ao.nn.quantized.reference.modules.utils
      
    torch.ao.nn.sparse
      
    torch.ao.nn.sparse.quantized
      
    torch.ao.nn.sparse.quantized.dynamic
      
    torch.ao.nn.sparse.quantized.dynamic.linear
      
    torch.ao.nn.sparse.quantized.linear
      
    torch.ao.nn.sparse.quantized.utils
      
    torch.ao.ns
      
    torch.ao.ns._numeric_suite
      
    torch.ao.ns._numeric_suite_fx
      
    torch.ao.ns.fx
      
    torch.ao.ns.fx.graph_matcher
      
    torch.ao.ns.fx.graph_passes
      
    torch.ao.ns.fx.mappings
      
    torch.ao.ns.fx.n_shadows_utils
      
    torch.ao.ns.fx.ns_types
      
    torch.ao.ns.fx.pattern_utils
      
    torch.ao.ns.fx.qconfig_multi_mapping
      
    torch.ao.ns.fx.utils
      
    torch.ao.ns.fx.weight_utils
      
    torch.ao.pruning
      
    torch.ao.pruning.scheduler
      
    torch.ao.pruning.scheduler.base_scheduler
      
    torch.ao.pruning.scheduler.cubic_scheduler
      
    torch.ao.pruning.scheduler.lambda_scheduler
      
    torch.ao.pruning.sparsifier
      
    torch.ao.pruning.sparsifier.base_sparsifier
      
    torch.ao.pruning.sparsifier.nearly_diagonal_sparsifier
      
    torch.ao.pruning.sparsifier.utils
      
    torch.ao.pruning.sparsifier.weight_norm_sparsifier
      
    torch.ao.quantization
      
    torch.ao.quantization.backend_config
      
    torch.ao.quantization.backend_config.backend_config
      
    torch.ao.quantization.backend_config.executorch
      
    torch.ao.quantization.backend_config.fbgemm
      
    torch.ao.quantization.backend_config.native
      
    torch.ao.quantization.backend_config.observation_type
      
    torch.ao.quantization.backend_config.onednn
      
    torch.ao.quantization.backend_config.qnnpack
      
    torch.ao.quantization.backend_config.tensorrt
      
    torch.ao.quantization.backend_config.utils
      
    torch.ao.quantization.backend_config.x86
      
    torch.ao.quantization.fake_quantize
      
    torch.ao.quantization.fuse_modules
      
    torch.ao.quantization.fuser_method_mappings
      
    torch.ao.quantization.fx
      
    torch.ao.quantization.fx.convert
      
    torch.ao.quantization.fx.custom_config
      
    torch.ao.quantization.fx.fuse
      
    torch.ao.quantization.fx.fuse_handler
      
    torch.ao.quantization.fx.graph_module
      
    torch.ao.quantization.fx.lower_to_fbgemm
      
    torch.ao.quantization.fx.lower_to_qnnpack
      
    torch.ao.quantization.fx.lstm_utils
      
    torch.ao.quantization.fx.match_utils
      
    torch.ao.quantization.fx.pattern_utils
      
    torch.ao.quantization.fx.prepare
      
    torch.ao.quantization.fx.qconfig_mapping_utils
      
    torch.ao.quantization.fx.quantize_handler
      
    torch.ao.quantization.fx.tracer
      
    torch.ao.quantization.fx.utils
      
    torch.ao.quantization.observer
      
    torch.ao.quantization.pt2e
      
    torch.ao.quantization.pt2e.duplicate_dq_pass
      
    torch.ao.quantization.pt2e.export_utils
      
    torch.ao.quantization.pt2e.generate_numeric_debug_handle
      
    torch.ao.quantization.pt2e.graph_utils
      
    torch.ao.quantization.pt2e.port_metadata_pass
      
    torch.ao.quantization.pt2e.prepare
      
    torch.ao.quantization.pt2e.qat_utils
      
    torch.ao.quantization.pt2e.representation
      
    torch.ao.quantization.pt2e.representation.rewrite
      
    torch.ao.quantization.pt2e.utils
      
    torch.ao.quantization.qconfig
      
    torch.ao.quantization.qconfig_mapping
      
    torch.ao.quantization.quant_type
      
    torch.ao.quantization.quantization_mappings
      
    torch.ao.quantization.quantize
      
    torch.ao.quantization.quantize_fx
      
    torch.ao.quantization.quantize_jit
      
    torch.ao.quantization.quantize_pt2e
      
    torch.ao.quantization.quantizer
      
    torch.ao.quantization.quantizer.composable_quantizer
      
    torch.ao.quantization.quantizer.embedding_quantizer
      
    torch.ao.quantization.quantizer.quantizer
      
    torch.ao.quantization.quantizer.utils
      
    torch.ao.quantization.quantizer.x86_inductor_quantizer
      
    torch.ao.quantization.quantizer.xnnpack_quantizer
      
    torch.ao.quantization.quantizer.xnnpack_quantizer_utils
      
    torch.ao.quantization.stubs
      
    torch.ao.quantization.utils
      
    torch.autograd
      
    torch.autograd.anomaly_mode
      
    torch.autograd.forward_ad
      
    torch.autograd.function
      
    torch.autograd.functional
      
    torch.autograd.grad_mode
      
    torch.autograd.gradcheck
      
    torch.autograd.graph
      
    torch.autograd.profiler
      
    torch.autograd.profiler_legacy
      
    torch.autograd.profiler_util
      
    torch.autograd.variable
      
    torch.backends
      
    torch.backends.cpu
      
    torch.backends.cuda
      
    torch.backends.cudnn
      
    torch.backends.cudnn.rnn
      
    torch.backends.mha
      
    torch.backends.mkl
      
    torch.backends.mkldnn
      
    torch.backends.mps
      
    torch.backends.nnpack
      
    torch.backends.openmp
      
    torch.backends.opt_einsum
      
    torch.backends.quantized
      
    torch.backends.xeon
      
    torch.backends.xeon.run_cpu
      
    torch.backends.xnnpack
      
    torch.compiler
      
    torch.contrib
      
    torch.cpu
      
    torch.cpu.amp
      
    torch.cpu.amp.autocast_mode
      
    torch.cpu.amp.grad_scaler
      
    torch.cuda
      
    torch.cuda._sanitizer
      
    torch.cuda.amp
      
    torch.cuda.amp.autocast_mode
      
    torch.cuda.amp.common
      
    torch.cuda.amp.grad_scaler
      
    torch.cuda.comm
      
    torch.cuda.error
      
    torch.cuda.graphs
      
    torch.cuda.jiterator
      
    torch.cuda.memory
      
    torch.cuda.nccl
      
    torch.cuda.nvtx
      
    torch.cuda.profiler
      
    torch.cuda.random
      
    torch.cuda.sparse
      
    torch.cuda.streams
      
    torch.distributed
      
    torch.distributed.algorithms
      
    torch.distributed.algorithms.ddp_comm_hooks
      
    torch.distributed.algorithms.ddp_comm_hooks.ddp_zero_hook
      
    torch.distributed.algorithms.ddp_comm_hooks.debugging_hooks
      
    torch.distributed.algorithms.ddp_comm_hooks.default_hooks
      
    torch.distributed.algorithms.ddp_comm_hooks.mixed_precision_hooks
      
    torch.distributed.algorithms.ddp_comm_hooks.optimizer_overlap_hooks
      
    torch.distributed.algorithms.ddp_comm_hooks.post_localSGD_hook
      
    torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook
      
    torch.distributed.algorithms.ddp_comm_hooks.quantization_hooks
      
    torch.distributed.algorithms.join
      
    torch.distributed.algorithms.model_averaging
      
    torch.distributed.algorithms.model_averaging.averagers
      
    torch.distributed.algorithms.model_averaging.hierarchical_model_averager
      
    torch.distributed.algorithms.model_averaging.utils
      
    torch.distributed.argparse_util
      
    torch.distributed.autograd
      
    torch.distributed.c10d_logger
      
    torch.distributed.checkpoint
      
    torch.distributed.checkpoint.api
      
    torch.distributed.checkpoint.default_planner
      
    torch.distributed.checkpoint.filesystem
      
    torch.distributed.checkpoint.format_utils
      
    torch.distributed.checkpoint.fsspec
      
    torch.distributed.checkpoint.metadata
      
    torch.distributed.checkpoint.optimizer
      
    torch.distributed.checkpoint.planner
      
    torch.distributed.checkpoint.planner_helpers
      
    torch.distributed.checkpoint.resharding
      
    torch.distributed.checkpoint.state_dict
      
    torch.distributed.checkpoint.state_dict_loader
      
    torch.distributed.checkpoint.state_dict_saver
      
    torch.distributed.checkpoint.stateful
      
    torch.distributed.checkpoint.storage
      
    torch.distributed.checkpoint.utils
      
    torch.distributed.collective_utils
      
    torch.distributed.constants
      
    torch.distributed.device_mesh
      
    torch.distributed.distributed_c10d
      
    torch.distributed.elastic
      
    torch.distributed.elastic.agent
      
    torch.distributed.elastic.agent.server
      
    torch.distributed.elastic.agent.server.api
      
    torch.distributed.elastic.agent.server.local_elastic_agent
      
    torch.distributed.elastic.events
      
    torch.distributed.elastic.events.api
      
    torch.distributed.elastic.events.handlers
      
    torch.distributed.elastic.metrics
      
    torch.distributed.elastic.metrics.api
      
    torch.distributed.elastic.multiprocessing
      
    torch.distributed.elastic.multiprocessing.api
      
    torch.distributed.elastic.multiprocessing.errors
      
    torch.distributed.elastic.multiprocessing.errors.error_handler
      
    torch.distributed.elastic.multiprocessing.errors.handlers
      
    torch.distributed.elastic.multiprocessing.redirects
      
    torch.distributed.elastic.multiprocessing.subprocess_handler
      
    torch.distributed.elastic.multiprocessing.subprocess_handler.handlers
      
    torch.distributed.elastic.multiprocessing.subprocess_handler.subprocess_handler
      
    torch.distributed.elastic.multiprocessing.tail_log
      
    torch.distributed.elastic.rendezvous
      
    torch.distributed.elastic.rendezvous.api
      
    torch.distributed.elastic.rendezvous.c10d_rendezvous_backend
      
    torch.distributed.elastic.rendezvous.dynamic_rendezvous
      
    torch.distributed.elastic.rendezvous.etcd_rendezvous
      
    torch.distributed.elastic.rendezvous.etcd_rendezvous_backend
      
    torch.distributed.elastic.rendezvous.etcd_server
      
    torch.distributed.elastic.rendezvous.etcd_store
      
    torch.distributed.elastic.rendezvous.registry
      
    torch.distributed.elastic.rendezvous.static_tcp_rendezvous
      
    torch.distributed.elastic.rendezvous.utils
      
    torch.distributed.elastic.timer
      
    torch.distributed.elastic.timer.api
      
    torch.distributed.elastic.timer.file_based_local_timer
      
    torch.distributed.elastic.timer.local_timer
      
    torch.distributed.elastic.utils
      
    torch.distributed.elastic.utils.api
      
    torch.distributed.elastic.utils.data
      
    torch.distributed.elastic.utils.data.cycling_iterator
      
    torch.distributed.elastic.utils.data.elastic_distributed_sampler
      
    torch.distributed.elastic.utils.distributed
      
    torch.distributed.elastic.utils.log_level
      
    torch.distributed.elastic.utils.logging
      
    torch.distributed.elastic.utils.store
      
    torch.distributed.fsdp
      
    torch.distributed.fsdp.api
      
    torch.distributed.fsdp.fully_sharded_data_parallel
      
    torch.distributed.fsdp.sharded_grad_scaler
      
    torch.distributed.fsdp.wrap
      
    torch.distributed.launch
      
    torch.distributed.launcher
      
    torch.distributed.launcher.api
      
    torch.distributed.logging_handlers
      
    torch.distributed.nn
      
    torch.distributed.nn.api
      
    torch.distributed.nn.api.remote_module
      
    torch.distributed.nn.functional
      
    torch.distributed.nn.jit
      
    torch.distributed.nn.jit.instantiator
      
    torch.distributed.nn.jit.templates
      
    torch.distributed.nn.jit.templates.remote_module_template
      
    torch.distributed.optim
      
    torch.distributed.optim.apply_optimizer_in_backward
      
    torch.distributed.optim.functional_adadelta
      
    torch.distributed.optim.functional_adagrad
      
    torch.distributed.optim.functional_adam
      
    torch.distributed.optim.functional_adamax
      
    torch.distributed.optim.functional_adamw
      
    torch.distributed.optim.functional_rmsprop
      
    torch.distributed.optim.functional_rprop
      
    torch.distributed.optim.functional_sgd
      
    torch.distributed.optim.named_optimizer
      
    torch.distributed.optim.optimizer
      
    torch.distributed.optim.post_localSGD_optimizer
      
    torch.distributed.optim.utils
      
    torch.distributed.optim.zero_redundancy_optimizer
      
    torch.distributed.pipeline
      
    torch.distributed.pipeline.sync
      
    torch.distributed.pipeline.sync.batchnorm
      
    torch.distributed.pipeline.sync.checkpoint
      
    torch.distributed.pipeline.sync.copy
      
    torch.distributed.pipeline.sync.dependency
      
    torch.distributed.pipeline.sync.microbatch
      
    torch.distributed.pipeline.sync.phony
      
    torch.distributed.pipeline.sync.pipe
      
    torch.distributed.pipeline.sync.pipeline
      
    torch.distributed.pipeline.sync.skip
      
    torch.distributed.pipeline.sync.skip.layout
      
    torch.distributed.pipeline.sync.skip.namespace
      
    torch.distributed.pipeline.sync.skip.portal
      
    torch.distributed.pipeline.sync.skip.skippable
      
    torch.distributed.pipeline.sync.skip.tracker
      
    torch.distributed.pipeline.sync.stream
      
    torch.distributed.pipeline.sync.utils
      
    torch.distributed.pipeline.sync.worker
      
    torch.distributed.remote_device
      
    torch.distributed.rendezvous
      
    torch.distributed.rpc
      
    torch.distributed.rpc.api
      
    torch.distributed.rpc.backend_registry
      
    torch.distributed.rpc.constants
      
    torch.distributed.rpc.functions
      
    torch.distributed.rpc.internal
      
    torch.distributed.rpc.options
      
    torch.distributed.rpc.rref_proxy
      
    torch.distributed.rpc.server_process_global_profiler
      
    torch.distributed.run
      
    torch.distributed.tensor
      
    torch.distributed.tensor.parallel
      
    torch.distributed.tensor.parallel.api
      
    torch.distributed.tensor.parallel.ddp
      
    torch.distributed.tensor.parallel.fsdp
      
    torch.distributed.tensor.parallel.input_reshard
      
    torch.distributed.tensor.parallel.loss
      
    torch.distributed.tensor.parallel.style
      
    torch.distributed.utils
      
    torch.distributions
      
    torch.distributions.bernoulli
      
    torch.distributions.beta
      
    torch.distributions.binomial
      
    torch.distributions.categorical
      
    torch.distributions.cauchy
      
    torch.distributions.chi2
      
    torch.distributions.constraint_registry
      
    torch.distributions.constraints
      
    torch.distributions.continuous_bernoulli
      
    torch.distributions.dirichlet
      
    torch.distributions.distribution
      
    torch.distributions.exp_family
      
    torch.distributions.exponential
      
    torch.distributions.fishersnedecor
      
    torch.distributions.gamma
      
    torch.distributions.geometric
      
    torch.distributions.gumbel
      
    torch.distributions.half_cauchy
      
    torch.distributions.half_normal
      
    torch.distributions.independent
      
    torch.distributions.inverse_gamma
      
    torch.distributions.kl
      
    torch.distributions.kumaraswamy
      
    torch.distributions.laplace
      
    torch.distributions.lkj_cholesky
      
    torch.distributions.log_normal
      
    torch.distributions.logistic_normal
      
    torch.distributions.lowrank_multivariate_normal
      
    torch.distributions.mixture_same_family
      
    torch.distributions.multinomial
      
    torch.distributions.multivariate_normal
      
    torch.distributions.negative_binomial
      
    torch.distributions.normal
      
    torch.distributions.one_hot_categorical
      
    torch.distributions.pareto
      
    torch.distributions.poisson
      
    torch.distributions.relaxed_bernoulli
      
    torch.distributions.relaxed_categorical
      
    torch.distributions.studentT
      
    torch.distributions.transformed_distribution
      
    torch.distributions.transforms
      
    torch.distributions.uniform
      
    torch.distributions.utils
      
    torch.distributions.von_mises
      
    torch.distributions.weibull
       | 
      
    torch.distributions.wishart
      
    torch.export
      
    torch.export.custom_obj
      
    torch.export.dynamic_shapes
      
    torch.export.exported_program
      
    torch.export.graph_signature
      
    torch.export.unflatten
      
    torch.fft
      torch.finfo (torch 中的类)
    torch.func
      
    torch.functional
      
    torch.futures
      
    torch.fx
      
    torch.fx.annotate
      
    torch.fx.config
      
    torch.fx.experimental
      
    torch.fx.experimental.accelerator_partitioner
      
    torch.fx.experimental.const_fold
      
    torch.fx.experimental.debug
      
    torch.fx.experimental.graph_gradual_typechecker
      
    torch.fx.experimental.merge_matmul
      
    torch.fx.experimental.meta_tracer
      
    torch.fx.experimental.migrate_gradual_types
      
    torch.fx.experimental.migrate_gradual_types.constraint
      
    torch.fx.experimental.migrate_gradual_types.constraint_generator
      
    torch.fx.experimental.migrate_gradual_types.constraint_transformation
      
    torch.fx.experimental.migrate_gradual_types.operation
      
    torch.fx.experimental.migrate_gradual_types.transform_to_z3
      
    torch.fx.experimental.migrate_gradual_types.util
      
    torch.fx.experimental.migrate_gradual_types.z3_types
      
    torch.fx.experimental.normalize
      
    torch.fx.experimental.optimization
      
    torch.fx.experimental.partitioner_utils
      
    torch.fx.experimental.proxy_tensor
      
    torch.fx.experimental.recording
      
    torch.fx.experimental.refinement_types
      
    torch.fx.experimental.rewriter
      
    torch.fx.experimental.schema_type_annotation
      
    torch.fx.experimental.sym_node
      
    torch.fx.experimental.symbolic_shapes
      
    torch.fx.experimental.unification
      
    torch.fx.experimental.unification.core
      
    torch.fx.experimental.unification.dispatch
      
    torch.fx.experimental.unification.match
      
    torch.fx.experimental.unification.more
      
    torch.fx.experimental.unification.multipledispatch
      
    torch.fx.experimental.unification.multipledispatch.conflict
      
    torch.fx.experimental.unification.multipledispatch.core
      
    torch.fx.experimental.unification.multipledispatch.dispatcher
      
    torch.fx.experimental.unification.multipledispatch.utils
      
    torch.fx.experimental.unification.multipledispatch.variadic
      
    torch.fx.experimental.unification.unification_tools
      
    torch.fx.experimental.unification.utils
      
    torch.fx.experimental.unification.variable
      
    torch.fx.experimental.unify_refinements
      
    torch.fx.experimental.validator
      
    torch.fx.graph
      
    torch.fx.graph_module
      
    torch.fx.immutable_collections
      
    torch.fx.interpreter
      
    torch.fx.node
      
    torch.fx.operator_schemas
      
    torch.fx.passes
      
    torch.fx.passes.annotate_getitem_nodes
      
    torch.fx.passes.backends
      
    torch.fx.passes.backends.cudagraphs
      
    torch.fx.passes.dialect
      
    torch.fx.passes.dialect.common
      
    torch.fx.passes.dialect.common.cse_pass
      
    torch.fx.passes.fake_tensor_prop
      
    torch.fx.passes.graph_drawer
      
    torch.fx.passes.graph_manipulation
      
    torch.fx.passes.infra
      
    torch.fx.passes.infra.partitioner
      
    torch.fx.passes.infra.pass_base
      
    torch.fx.passes.infra.pass_manager
      
    torch.fx.passes.net_min_base
      
    torch.fx.passes.operator_support
      
    torch.fx.passes.param_fetch
      
    torch.fx.passes.pass_manager
      
    torch.fx.passes.reinplace
      
    torch.fx.passes.shape_prop
      
    torch.fx.passes.split_module
      
    torch.fx.passes.split_utils
      
    torch.fx.passes.splitter_base
      
    torch.fx.passes.tests
      
    torch.fx.passes.tests.test_pass_manager
      
    torch.fx.passes.tools_common
      
    torch.fx.passes.utils
      
    torch.fx.passes.utils.common
      
    torch.fx.passes.utils.fuser_utils
      
    torch.fx.passes.utils.matcher_utils
      
    torch.fx.passes.utils.matcher_with_name_node_map_utils
      
    torch.fx.passes.utils.source_matcher_utils
      
    torch.fx.proxy
      
    torch.fx.subgraph_rewriter
      
    torch.fx.tensor_type
      
    torch.fx.traceback
      
    torch.hub
      torch.iinfo (torch 中的类)
    torch.jit
      
    torch.jit.annotations
      
    torch.jit.frontend
      
    torch.jit.generate_bytecode
      
    torch.jit.mobile
      
    torch.jit.quantized
      
    torch.jit.supported_ops
      
    torch.jit.unsupported_tensor_ops
      
    torch.library
      
    torch.linalg
      
    torch.masked
      
    torch.masked.maskedtensor
      
    torch.masked.maskedtensor.binary
      
    torch.masked.maskedtensor.core
      
    torch.masked.maskedtensor.creation
      
    torch.masked.maskedtensor.passthrough
      
    torch.masked.maskedtensor.reductions
      
    torch.masked.maskedtensor.unary
      
    torch.monitor
      
    torch.mps
      
    torch.mps.event
      
    torch.mps.profiler
      
    torch.multiprocessing
      
    torch.multiprocessing.pool
      
    torch.multiprocessing.queue
      
    torch.multiprocessing.reductions
      
    torch.multiprocessing.spawn
      
    torch.nested
      
    torch.nn
      
    torch.nn.attention
      
    torch.nn.attention.bias
      
    torch.nn.backends
      
    torch.nn.backends.thnn
      
    torch.nn.common_types
      
    torch.nn.cpp
      
    torch.nn.functional
      
    torch.nn.grad
      
    torch.nn.init
      
    torch.nn.intrinsic
      
    torch.nn.intrinsic.modules
      
    torch.nn.intrinsic.modules.fused
      
    torch.nn.intrinsic.qat
      
    torch.nn.intrinsic.qat.modules
      
    torch.nn.intrinsic.qat.modules.conv_fused
      
    torch.nn.intrinsic.qat.modules.linear_fused
      
    torch.nn.intrinsic.qat.modules.linear_relu
      
    torch.nn.intrinsic.quantized
      
    torch.nn.intrinsic.quantized.dynamic
      
    torch.nn.intrinsic.quantized.dynamic.modules
      
    torch.nn.intrinsic.quantized.dynamic.modules.linear_relu
      
    torch.nn.intrinsic.quantized.modules
      
    torch.nn.intrinsic.quantized.modules.bn_relu
      
    torch.nn.intrinsic.quantized.modules.conv_relu
      
    torch.nn.intrinsic.quantized.modules.linear_relu
      
    torch.nn.modules
      
    torch.nn.modules.activation
      
    torch.nn.modules.adaptive
      
    torch.nn.modules.batchnorm
      
    torch.nn.modules.channelshuffle
      
    torch.nn.modules.container
      
    torch.nn.modules.conv
      
    torch.nn.modules.distance
      
    torch.nn.modules.dropout
      
    torch.nn.modules.flatten
      
    torch.nn.modules.fold
      
    torch.nn.modules.instancenorm
      
    torch.nn.modules.lazy
      
    torch.nn.modules.linear
      
    torch.nn.modules.loss
      
    torch.nn.modules.module
      
    torch.nn.modules.normalization
      
    torch.nn.modules.padding
      
    torch.nn.modules.pixelshuffle
      
    torch.nn.modules.pooling
      
    torch.nn.modules.rnn
      
    torch.nn.modules.sparse
      
    torch.nn.modules.transformer
      
    torch.nn.modules.upsampling
      
    torch.nn.modules.utils
      
    torch.nn.parallel
      
    torch.nn.parallel.comm
      
    torch.nn.parallel.data_parallel
      
    torch.nn.parallel.distributed
      
    torch.nn.parallel.parallel_apply
      
    torch.nn.parallel.replicate
      
    torch.nn.parallel.scatter_gather
      
    torch.nn.parameter
      
    torch.nn.qat
      
    torch.nn.qat.dynamic
      
    torch.nn.qat.dynamic.modules
      
    torch.nn.qat.dynamic.modules.linear
      
    torch.nn.qat.modules
      
    torch.nn.qat.modules.conv
      
    torch.nn.qat.modules.embedding_ops
      
    torch.nn.qat.modules.linear
      
    torch.nn.quantizable
      
    torch.nn.quantizable.modules
      
    torch.nn.quantizable.modules.activation
      
    torch.nn.quantizable.modules.rnn
      
    torch.nn.quantized
      
    torch.nn.quantized.dynamic
      
    torch.nn.quantized.dynamic.modules
      
    torch.nn.quantized.dynamic.modules.conv
      
    torch.nn.quantized.dynamic.modules.linear
      
    torch.nn.quantized.dynamic.modules.rnn
      
    torch.nn.quantized.functional
      
    torch.nn.quantized.modules
      
    torch.nn.quantized.modules.activation
      
    torch.nn.quantized.modules.batchnorm
      
    torch.nn.quantized.modules.conv
      
    torch.nn.quantized.modules.dropout
      
    torch.nn.quantized.modules.embedding_ops
      
    torch.nn.quantized.modules.functional_modules
      
    torch.nn.quantized.modules.linear
      
    torch.nn.quantized.modules.normalization
      
    torch.nn.quantized.modules.rnn
      
    torch.nn.quantized.modules.utils
      
    torch.nn.utils
      
    torch.nn.utils.clip_grad
      
    torch.nn.utils.convert_parameters
      
    torch.nn.utils.fusion
      
    torch.nn.utils.init
      
    torch.nn.utils.memory_format
      
    torch.nn.utils.parametrizations
      
    torch.nn.utils.parametrize
      
    torch.nn.utils.prune
      
    torch.nn.utils.rnn
      
    torch.nn.utils.spectral_norm
      
    torch.nn.utils.stateless
      
    torch.nn.utils.weight_norm
      
    torch.onnx
      
    torch.onnx.errors
      
    torch.onnx.operators
      
    torch.onnx.symbolic_caffe2
      
    torch.onnx.symbolic_helper
      
    torch.onnx.symbolic_opset10
      
    torch.onnx.symbolic_opset11
      
    torch.onnx.symbolic_opset12
      
    torch.onnx.symbolic_opset13
      
    torch.onnx.symbolic_opset14
      
    torch.onnx.symbolic_opset15
      
    torch.onnx.symbolic_opset16
      
    torch.onnx.symbolic_opset17
      
    torch.onnx.symbolic_opset18
      
    torch.onnx.symbolic_opset7
      
    torch.onnx.symbolic_opset8
      
    torch.onnx.symbolic_opset9
      
    torch.onnx.utils
      
    torch.onnx.verification
      
    torch.optim
      
    torch.optim.adadelta
      
    torch.optim.adagrad
      
    torch.optim.adam
      
    torch.optim.adamax
      
    torch.optim.adamw
      
    torch.optim.asgd
      
    torch.optim.lbfgs
      
    torch.optim.lr_scheduler
      
    torch.optim.nadam
      
    torch.optim.optimizer
      
    torch.optim.radam
      
    torch.optim.rmsprop
      
    torch.optim.rprop
      
    torch.optim.sgd
      
    torch.optim.sparse_adam
      
    torch.optim.swa_utils
      
    torch.overrides
      
    torch.package
      
    torch.package.analyze
      
    torch.package.analyze.find_first_use_of_broken_modules
      
    torch.package.analyze.is_from_package
      
    torch.package.analyze.trace_dependencies
      
    torch.package.file_structure_representation
      
    torch.package.find_file_dependencies
      
    torch.package.glob_group
      
    torch.package.importer
      
    torch.package.package_exporter
      
    torch.package.package_importer
      
    torch.profiler
      
    torch.profiler.itt
      
    torch.profiler.profiler
      
    torch.profiler.python_tracer
      
    torch.quantization
      
    torch.quantization.fake_quantize
      
    torch.quantization.fuse_modules
      
    torch.quantization.fuser_method_mappings
      
    torch.quantization.fx
      
    torch.quantization.fx.convert
      
    torch.quantization.fx.fuse
      
    torch.quantization.fx.fusion_patterns
      
    torch.quantization.fx.graph_module
      
    torch.quantization.fx.match_utils
      
    torch.quantization.fx.pattern_utils
      
    torch.quantization.fx.prepare
      
    torch.quantization.fx.quantization_patterns
      
    torch.quantization.fx.quantization_types
      
    torch.quantization.fx.utils
      
    torch.quantization.observer
      
    torch.quantization.qconfig
      
    torch.quantization.quant_type
      
    torch.quantization.quantization_mappings
      
    torch.quantization.quantize
      
    torch.quantization.quantize_fx
      
    torch.quantization.quantize_jit
      
    torch.quantization.stubs
      
    torch.quantization.utils
      
    torch.quasirandom
      
    torch.random
      
    torch.return_types
      
    torch.serialization
      
    torch.signal
      
    torch.signal.windows
      
    torch.signal.windows.windows
      
    torch.sparse
      
    torch.sparse.semi_structured
      
    torch.special
      
    torch.storage
      
    torch.testing
      
    torch.torch_version
      
    torch.types
      
    torch.utils
      
    torch.utils.backcompat
      
    torch.utils.backend_registration
      
    torch.utils.benchmark
      
    torch.utils.benchmark.examples
      
    torch.utils.benchmark.examples.blas_compare_setup
      
    torch.utils.benchmark.examples.compare
      
    torch.utils.benchmark.examples.fuzzer
      
    torch.utils.benchmark.examples.op_benchmark
      
    torch.utils.benchmark.examples.simple_timeit
      
    torch.utils.benchmark.examples.spectral_ops_fuzz_test
      
    torch.utils.benchmark.op_fuzzers
      
    torch.utils.benchmark.op_fuzzers.binary
      
    torch.utils.benchmark.op_fuzzers.sparse_binary
      
    torch.utils.benchmark.op_fuzzers.sparse_unary
      
    torch.utils.benchmark.op_fuzzers.spectral
      
    torch.utils.benchmark.op_fuzzers.unary
      
    torch.utils.benchmark.utils
      
    torch.utils.benchmark.utils.common
      
    torch.utils.benchmark.utils.compare
      
    torch.utils.benchmark.utils.compile
      
    torch.utils.benchmark.utils.cpp_jit
      
    torch.utils.benchmark.utils.fuzzer
      
    torch.utils.benchmark.utils.sparse_fuzzer
      
    torch.utils.benchmark.utils.timer
      
    torch.utils.benchmark.utils.valgrind_wrapper
      
    torch.utils.benchmark.utils.valgrind_wrapper.timer_interface
      
    torch.utils.bottleneck
      
    torch.utils.bundled_inputs
      
    torch.utils.checkpoint
      
    torch.utils.collect_env
      
    torch.utils.cpp_backtrace
      
    torch.utils.cpp_extension
      
    torch.utils.data
      
    torch.utils.data.backward_compatibility
      
    torch.utils.data.dataloader
      
    torch.utils.data.datapipes
      
    torch.utils.data.datapipes.dataframe
      
    torch.utils.data.datapipes.dataframe.dataframe_wrapper
      
    torch.utils.data.datapipes.dataframe.dataframes
      
    torch.utils.data.datapipes.dataframe.datapipes
      
    torch.utils.data.datapipes.dataframe.structures
      
    torch.utils.data.datapipes.datapipe
      
    torch.utils.data.datapipes.gen_pyi
      
    torch.utils.data.datapipes.iter
      
    torch.utils.data.datapipes.iter.callable
      
    torch.utils.data.datapipes.iter.combinatorics
      
    torch.utils.data.datapipes.iter.combining
      
    torch.utils.data.datapipes.iter.filelister
      
    torch.utils.data.datapipes.iter.fileopener
      
    torch.utils.data.datapipes.iter.grouping
      
    torch.utils.data.datapipes.iter.routeddecoder
      
    torch.utils.data.datapipes.iter.selecting
      
    torch.utils.data.datapipes.iter.sharding
      
    torch.utils.data.datapipes.iter.streamreader
      
    torch.utils.data.datapipes.iter.utils
      
    torch.utils.data.datapipes.map
      
    torch.utils.data.datapipes.map.callable
      
    torch.utils.data.datapipes.map.combinatorics
      
    torch.utils.data.datapipes.map.combining
      
    torch.utils.data.datapipes.map.grouping
      
    torch.utils.data.datapipes.map.utils
      
    torch.utils.data.datapipes.utils
      
    torch.utils.data.datapipes.utils.common
      
    torch.utils.data.datapipes.utils.decoder
      
    torch.utils.data.datapipes.utils.snapshot
      
    torch.utils.data.dataset
      
    torch.utils.data.distributed
      
    torch.utils.data.graph
      
    torch.utils.data.graph_settings
      
    torch.utils.data.sampler
      
    torch.utils.deterministic
      
    torch.utils.dlpack
      
    torch.utils.file_baton
      
    torch.utils.flop_counter
      
    torch.utils.hipify
      
    torch.utils.hipify.constants
      
    torch.utils.hipify.cuda_to_hip_mappings
      
    torch.utils.hipify.hipify_python
      
    torch.utils.hipify.version
      
    torch.utils.hooks
      
    torch.utils.jit
      
    torch.utils.jit.log_extract
      
    torch.utils.mkldnn
      
    torch.utils.mobile_optimizer
      
    torch.utils.model_dump
      
    torch.utils.model_zoo
      
    torch.utils.show_pickle
      
    torch.utils.tensorboard
      
    torch.utils.tensorboard.summary
      
    torch.utils.tensorboard.writer
      
    torch.utils.throughput_benchmark
      
    torch.utils.viz
      
    torch.utils.weak
      
    torch.version
      
    torch.xpu
      
    torch.xpu.random
      
    torch.xpu.streams
      torch_name() (torch.onnx.JitScalarType 方法)
torch_save_to_dcp() (在模块 torch.distributed.checkpoint.format_utils 中)
total_average() (torch.autograd.profiler.profile 方法)
total_count (torch.distributions.multinomial.Multinomial 属性)
trace() (在模块 torch 中)
      trace_module() (在模块 torch.jit 中)
跟踪器 (torch.fx 中的类)
train() (torch.jit.ScriptModule 方法)
      变换 (torch.distributions.transforms 中的类)
transform() (torch.fx.Transformer 方法)
      transform_object() (torch.distributed.checkpoint.DefaultSavePlanner 方法)
transform_tensor() (torch.distributed.checkpoint.DefaultLoadPlanner 方法)
TransformedDistribution (torch.distributions.transformed_distribution 中的类)
转换器 (torch.fx 中的类)
      TransformerDecoder (torch.nn 中的类)
TransformerDecoderLayer (torch.nn 中的类)
TransformerEncoder (torch.nn 中的类)
TransformerEncoderLayer (torch.nn 中的类)
transpose() (在模块 torch 中)
      transpose_() (torch.Tensor 方法)
trapezoid() (在模块 torch 中)
trapz() (在模块 torch 中)
triangular_solve() (在模块 torch 中)
      tril() (在模块 torch 中)
      tril_() (torch.Tensor 方法)
tril_indices() (在模块 torch 中)
triplet_margin_loss() (在模块 torch.nn.functional 中)
triplet_margin_with_distance_loss() (在模块 torch.nn.functional 中)
TripletMarginLoss (torch.nn 中的类)
TripletMarginWithDistanceLoss (torch.nn 中的类)
triu() (在模块 torch 中)
      triu_() (torch.Tensor 方法)
triu_indices() (在模块 torch 中)
true_divide() (在模块 torch 中)
      true_divide_() (torch.Tensor 方法)
trunc() (在模块 torch 中)
      trunc_() (torch.Tensor 方法)
trunc_normal_() (在模块 torch.nn.init 中)
type (torch.jit.Attribute 属性)
type() (torch.jit.ScriptModule 方法)
      type_as() (torch.Tensor 方法)
TypedStorage (torch 中的类)
 |