A platform combines multiple tutorials, projects, documentations, questions and answers for developers
  • Home (current)
  • Documentations
  • About
  • Login
  1. Home
  2. Documentations
  3. PyTorch
  4. torch.true_divide

torch.true_divide

torch.true_divide(dividend, divisor, *, out) → Tensor

Alias for torch.div() with rounding_mode=None.

© 2019 Torch Contributors
Licensed under the 3-clause BSD License.
https://pytorch.org/docs/1.8.0/generated/torch.true_divide.html

torch.nn.functional
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.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.gelu()
torch.nn.functional.glu()
torch.nn.functional.grid_sample()
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.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.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.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.rrelu()
torch.nn.functional.rrelu_()
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.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.parallel.data_parallel()
DDP Communication Hooks
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.allreduce_hook()
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook()
torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState
torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook()
torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook()
torch.backends
clear()
max_size
torch
torch
torch.Generator
torch.Generator.device
torch.Generator.get_state()
torch.Generator.initial_seed()
torch.Generator.manual_seed()
torch.Generator.seed()
torch.Generator.set_state()
torch._assert()
torch.abs()
torch.absolute()
torch.acos()
torch.acosh()
torch.add()
torch.addbmm()
torch.addcdiv()
torch.addcmul()
torch.addmm()
torch.addmv()
torch.addr()
torch.all()
torch.allclose()
torch.amax()
torch.amin()
torch.angle()
torch.any()
torch.arange()
torch.arccos()
torch.arccosh()
torch.arcsin()
torch.arcsinh()
torch.arctan()
torch.arctanh()
torch.are_deterministic_algorithms_enabled()
torch.argmax()
torch.argmin()
torch.argsort()
torch.as_strided()
torch.as_tensor()
torch.asin()
torch.asinh()
torch.atan()
torch.atan2()
torch.atanh()
torch.atleast_1d()
torch.atleast_2d()
torch.atleast_3d()
torch.backends
torch.backends.cuda.cufft_plan_cache
torch.backends.cuda.is_built()
torch.backends.cuda.matmul.allow_tf32
torch.backends.cuda.size
torch.backends.cudnn.allow_tf32
torch.backends.cudnn.benchmark
torch.backends.cudnn.deterministic
torch.backends.cudnn.enabled
torch.backends.cudnn.is_available()
torch.backends.cudnn.version()
torch.backends.mkl.is_available()
torch.backends.mkldnn.is_available()
torch.backends.openmp.is_available()
torch.baddbmm()
torch.bartlett_window()
torch.bernoulli()
torch.bincount()
torch.bitwise_and()
torch.bitwise_not()
torch.bitwise_or()
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.compiled_with_cxx11_abi()
torch.complex()
torch.conj()
torch.copysign()
torch.cos()
torch.cosh()
torch.count_nonzero()
torch.cross()
torch.cummax()
torch.cummin()
torch.cumprod()
torch.cumsum()
torch.deg2rad()
torch.dequantize()
torch.det()
torch.diag()
torch.diag_embed()
torch.diagflat()
torch.diagonal()
torch.diff()
torch.digamma()
torch.dist()
torch.div()
torch.divide()
torch.dot()
torch.dstack()
torch.eig()
torch.einsum()
torch.empty()
torch.empty_like()
torch.empty_strided()
torch.enable_grad
torch.eq()
torch.equal()
torch.erf()
torch.erfc()
torch.erfinv()
torch.exp()
torch.exp2()
torch.expm1()
torch.eye()
torch.fake_quantize_per_channel_affine()
torch.fake_quantize_per_tensor_affine()
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.from_numpy()
torch.full()
torch.full_like()
torch.gather()
torch.gcd()
torch.ge()
torch.geqrf()
torch.ger()
torch.get_default_dtype()
torch.get_num_interop_threads()
torch.get_num_threads()
torch.get_rng_state()
torch.greater()
torch.greater_equal()
torch.gt()
torch.hamming_window()
torch.hann_window()
torch.heaviside()
torch.histc()
torch.hstack()
torch.hypot()
torch.i0()
torch.igamma()
torch.igammac()
torch.imag()
torch.index_select()
torch.initial_seed()
torch.inner()
torch.inverse()
torch.is_complex()
torch.is_floating_point()
torch.is_nonzero()
torch.is_storage()
torch.is_tensor()
torch.isclose()
torch.isfinite()
torch.isinf()
torch.isnan()
torch.isneginf()
torch.isposinf()
torch.isreal()
torch.istft()
torch.kaiser_window()
torch.kron()
torch.kthvalue()
torch.lcm()
torch.ldexp()
torch.le()
torch.lerp()
torch.less()
torch.less_equal()
torch.lgamma()
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.lstsq()
torch.lt()
torch.lu()
torch.lu_solve()
torch.lu_unpack()
torch.manual_seed()
torch.masked_select()
torch.matmul()
torch.matrix_exp()
torch.matrix_power()
torch.matrix_rank()
torch.max()
torch.maximum()
torch.mean()
torch.median()
torch.meshgrid()
torch.min()
torch.minimum()
torch.mm()
torch.mode()
torch.moveaxis()
torch.movedim()
torch.msort()
torch.mul()
torch.multinomial()
torch.multiply()
torch.mv()
torch.mvlgamma()
torch.nan_to_num()
torch.nanmedian()
torch.nanquantile()
torch.nansum()
torch.narrow()
torch.ne()
torch.neg()
torch.negative()
torch.nextafter()
torch.no_grad
torch.nonzero()
torch.norm()
torch.normal()
torch.not_equal()
torch.numel()
torch.ones()
torch.ones_like()
torch.orgqr()
torch.ormqr()
torch.outer()
torch.pca_lowrank()
torch.pinverse()
torch.poisson()
torch.polar()
torch.polygamma()
torch.pow()
torch.prod()
torch.promote_types()
torch.qr()
torch.quantile()
torch.quantize_per_channel()
torch.quantize_per_tensor()
torch.quasirandom.SobolEngine
torch.quasirandom.SobolEngine.draw()
torch.quasirandom.SobolEngine.draw_base2()
torch.quasirandom.SobolEngine.fast_forward()
torch.quasirandom.SobolEngine.reset()
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.result_type()
torch.roll()
torch.rot90()
torch.round()
torch.row_stack()
torch.rsqrt()
torch.save()
torch.scatter()
torch.scatter_add()
torch.searchsorted()
torch.seed()
torch.set_default_dtype()
torch.set_default_tensor_type()
torch.set_flush_denormal()
torch.set_grad_enabled
torch.set_num_interop_threads()
torch.set_num_threads()
torch.set_printoptions()
torch.set_rng_state()
torch.sgn()
torch.sigmoid()
torch.sign()
torch.signbit()
torch.sin()
torch.sinc()
torch.sinh()
torch.slogdet()
torch.solve()
torch.sort()
torch.sparse_coo_tensor()
torch.split()
torch.sqrt()
torch.square()
torch.squeeze()
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.symeig()
torch.t()
torch.take()
torch.tan()
torch.tanh()
torch.tensor()
torch.tensor_split()
torch.tensordot()
torch.tile()
torch.topk()
torch.torch.default_generator
torch.trace()
torch.transpose()
torch.trapz()
torch.triangular_solve()
torch.tril()
torch.tril_indices()
torch.triu()
torch.triu_indices()
torch.true_divide()
torch.trunc()
torch.unbind()
torch.unique()
torch.unique_consecutive()
torch.unsqueeze()
torch.use_deterministic_algorithms()
torch.vander()
torch.var()
torch.var_mean()
torch.vdot()
torch.view_as_complex()
torch.view_as_real()
torch.vstack()
torch.where()
torch.xlogy()
torch.zeros()
torch.zeros_like()
torch.autograd
torch.Tensor.backward()
torch.Tensor.detach()
torch.Tensor.detach_()
torch.Tensor.grad
torch.Tensor.is_leaf
torch.Tensor.register_hook()
torch.Tensor.requires_grad
torch.Tensor.retain_grad()
torch.autograd
torch.autograd.Function
torch.autograd.Function.backward()
torch.autograd.Function.forward()
torch.autograd.backward()
torch.autograd.detect_anomaly
torch.autograd.enable_grad
torch.autograd.function._ContextMethodMixin
torch.autograd.function._ContextMethodMixin.mark_dirty()
torch.autograd.function._ContextMethodMixin.mark_non_differentiable()
torch.autograd.function._ContextMethodMixin.save_for_backward()
torch.autograd.function._ContextMethodMixin.set_materialize_grads()
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()
torch.autograd.gradgradcheck()
torch.autograd.no_grad
torch.autograd.profiler.emit_nvtx
torch.autograd.profiler.load_nvprof()
torch.autograd.profiler.profile
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.table()
torch.autograd.profiler.profile.total_average()
torch.autograd.set_detect_anomaly
torch.autograd.set_grad_enabled
torch.cuda
torch.cuda
torch.cuda.Event
torch.cuda.Event.elapsed_time()
torch.cuda.Event.from_ipc_handle()
torch.cuda.Event.ipc_handle()
torch.cuda.Event.query()
torch.cuda.Event.record()
torch.cuda.Event.synchronize()
torch.cuda.Event.wait()
torch.cuda.Stream
torch.cuda.Stream.query()
torch.cuda.Stream.record_event()
torch.cuda.Stream.synchronize()
torch.cuda.Stream.wait_event()
torch.cuda.Stream.wait_stream()
torch.cuda.can_device_access_peer()
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
torch.cuda.device_count()
torch.cuda.device_of
torch.cuda.empty_cache()
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.init()
torch.cuda.initial_seed()
torch.cuda.ipc_collect()
torch.cuda.is_available()
torch.cuda.is_initialized()
torch.cuda.list_gpu_processes()
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.memory_allocated()
torch.cuda.memory_cached()
torch.cuda.memory_reserved()
torch.cuda.memory_snapshot()
torch.cuda.memory_stats()
torch.cuda.memory_summary()
torch.cuda.nvtx.mark()
torch.cuda.nvtx.range_pop()
torch.cuda.nvtx.range_push()
torch.cuda.reset_max_memory_allocated()
torch.cuda.reset_max_memory_cached()
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.stream()
torch.cuda.synchronize()
torch.cuda.amp
torch.cuda.amp
torch.cuda.amp.GradScaler
torch.cuda.amp.GradScaler.get_backoff_factor()
torch.cuda.amp.GradScaler.get_growth_factor()
torch.cuda.amp.GradScaler.get_growth_interval()
torch.cuda.amp.GradScaler.get_scale()
torch.cuda.amp.GradScaler.is_enabled()
torch.cuda.amp.GradScaler.load_state_dict()
torch.cuda.amp.GradScaler.scale()
torch.cuda.amp.GradScaler.set_backoff_factor()
torch.cuda.amp.GradScaler.set_growth_factor()
torch.cuda.amp.GradScaler.set_growth_interval()
torch.cuda.amp.GradScaler.state_dict()
torch.cuda.amp.GradScaler.step()
torch.cuda.amp.GradScaler.unscale_()
torch.cuda.amp.GradScaler.update()
torch.cuda.amp.autocast
torch.cuda.amp.custom_bwd()
torch.cuda.amp.custom_fwd()
torch.distributed
torch.distributed
torch.distributed.Backend
torch.distributed.FileStore
torch.distributed.HashStore
torch.distributed.PrefixStore
torch.distributed.ReduceOp
torch.distributed.Store
torch.distributed.Store.add()
torch.distributed.Store.delete_key()
torch.distributed.Store.get()
torch.distributed.Store.num_keys()
torch.distributed.Store.set()
torch.distributed.Store.set_timeout()
torch.distributed.Store.wait()
torch.distributed.TCPStore
torch.distributed.all_gather()
torch.distributed.all_gather_multigpu()
torch.distributed.all_gather_object()
torch.distributed.all_reduce()
torch.distributed.all_reduce_multigpu()
torch.distributed.all_to_all()
torch.distributed.barrier()
torch.distributed.broadcast()
torch.distributed.broadcast_multigpu()
torch.distributed.broadcast_object_list()
torch.distributed.gather()
torch.distributed.gather_object()
torch.distributed.get_backend()
torch.distributed.get_rank()
torch.distributed.get_world_size()
torch.distributed.init_process_group()
torch.distributed.irecv()
torch.distributed.is_available()
torch.distributed.is_initialized()
torch.distributed.is_mpi_available()
torch.distributed.is_nccl_available()
torch.distributed.isend()
torch.distributed.new_group()
torch.distributed.recv()
torch.distributed.reduce()
torch.distributed.reduce_multigpu()
torch.distributed.reduce_op
torch.distributed.reduce_scatter()
torch.distributed.reduce_scatter_multigpu()
torch.distributed.scatter()
torch.distributed.scatter_object_list()
torch.distributed.send()
Distributed RPC Framework
torch.distributed.autograd.backward()
torch.distributed.autograd.context
torch.distributed.autograd.get_gradients()
torch.distributed.optim.DistributedOptimizer
torch.distributed.optim.DistributedOptimizer.step()
torch.distributed.rpc.BackendType
torch.distributed.rpc.ProcessGroupRpcBackendOptions
torch.distributed.rpc.ProcessGroupRpcBackendOptions.init_method()
torch.distributed.rpc.ProcessGroupRpcBackendOptions.num_send_recv_threads()
torch.distributed.rpc.ProcessGroupRpcBackendOptions.rpc_timeout()
torch.distributed.rpc.RRef
torch.distributed.rpc.RRef.backward()
torch.distributed.rpc.RRef.confirmed_by_owner()
torch.distributed.rpc.RRef.is_owner()
torch.distributed.rpc.RRef.local_value()
torch.distributed.rpc.RRef.owner()
torch.distributed.rpc.RRef.owner_name()
torch.distributed.rpc.RRef.remote()
torch.distributed.rpc.RRef.rpc_async()
torch.distributed.rpc.RRef.rpc_sync()
torch.distributed.rpc.RRef.to_here()
torch.distributed.rpc.RpcBackendOptions
torch.distributed.rpc.RpcBackendOptions.init_method()
torch.distributed.rpc.RpcBackendOptions.rpc_timeout()
torch.distributed.rpc.TensorPipeRpcBackendOptions
torch.distributed.rpc.TensorPipeRpcBackendOptions.device_maps()
torch.distributed.rpc.TensorPipeRpcBackendOptions.init_method()
torch.distributed.rpc.TensorPipeRpcBackendOptions.num_worker_threads()
torch.distributed.rpc.TensorPipeRpcBackendOptions.rpc_timeout()
torch.distributed.rpc.TensorPipeRpcBackendOptions.set_device_map()
torch.distributed.rpc.WorkerInfo
torch.distributed.rpc.WorkerInfo.id()
torch.distributed.rpc.WorkerInfo.name()
torch.distributed.rpc.functions.async_execution()
torch.distributed.rpc.get_worker_info()
torch.distributed.rpc.init_rpc()
torch.distributed.rpc.remote()
torch.distributed.rpc.rpc_async()
torch.distributed.rpc.rpc_sync()
torch.distributed.rpc.shutdown()
Pipeline Parallelism
torch.distributed.pipeline.sync.Pipe
torch.distributed.pipeline.sync.Pipe.forward()
torch.distributed.pipeline.sync.skip.skippable.pop
torch.distributed.pipeline.sync.skip.skippable.skippable()
torch.distributed.pipeline.sync.skip.skippable.stash
torch.distributed.pipeline.sync.skip.skippable.verify_skippables()
torch.distributions
torch.distributions
torch.distributions.bernoulli.Bernoulli
torch.distributions.bernoulli.Bernoulli.arg_constraints
torch.distributions.bernoulli.Bernoulli.entropy()
torch.distributions.bernoulli.Bernoulli.enumerate_support()
torch.distributions.bernoulli.Bernoulli.expand()
torch.distributions.bernoulli.Bernoulli.has_enumerate_support
torch.distributions.bernoulli.Bernoulli.log_prob()
torch.distributions.bernoulli.Bernoulli.logits
torch.distributions.bernoulli.Bernoulli.mean()
torch.distributions.bernoulli.Bernoulli.param_shape()
torch.distributions.bernoulli.Bernoulli.probs
torch.distributions.bernoulli.Bernoulli.sample()
torch.distributions.bernoulli.Bernoulli.support
torch.distributions.bernoulli.Bernoulli.variance()
torch.distributions.beta.Beta
torch.distributions.beta.Beta.arg_constraints
torch.distributions.beta.Beta.concentration0()
torch.distributions.beta.Beta.concentration1()
torch.distributions.beta.Beta.entropy()
torch.distributions.beta.Beta.expand()
torch.distributions.beta.Beta.has_rsample
torch.distributions.beta.Beta.log_prob()
torch.distributions.beta.Beta.mean()
torch.distributions.beta.Beta.rsample()
torch.distributions.beta.Beta.support
torch.distributions.beta.Beta.variance()
torch.distributions.binomial.Binomial
torch.distributions.binomial.Binomial.arg_constraints
torch.distributions.binomial.Binomial.enumerate_support()
torch.distributions.binomial.Binomial.expand()
torch.distributions.binomial.Binomial.has_enumerate_support
torch.distributions.binomial.Binomial.log_prob()
torch.distributions.binomial.Binomial.logits
torch.distributions.binomial.Binomial.mean()
torch.distributions.binomial.Binomial.param_shape()
torch.distributions.binomial.Binomial.probs
torch.distributions.binomial.Binomial.sample()
torch.distributions.binomial.Binomial.support()
torch.distributions.binomial.Binomial.variance()
torch.distributions.categorical.Categorical
torch.distributions.categorical.Categorical.arg_constraints
torch.distributions.categorical.Categorical.entropy()
torch.distributions.categorical.Categorical.enumerate_support()
torch.distributions.categorical.Categorical.expand()
torch.distributions.categorical.Categorical.has_enumerate_support
torch.distributions.categorical.Categorical.log_prob()
torch.distributions.categorical.Categorical.logits
torch.distributions.categorical.Categorical.mean()
torch.distributions.categorical.Categorical.param_shape()
torch.distributions.categorical.Categorical.probs
torch.distributions.categorical.Categorical.sample()
torch.distributions.categorical.Categorical.support()
torch.distributions.categorical.Categorical.variance()
torch.distributions.cauchy.Cauchy
torch.distributions.cauchy.Cauchy.arg_constraints
torch.distributions.cauchy.Cauchy.cdf()
torch.distributions.cauchy.Cauchy.entropy()
torch.distributions.cauchy.Cauchy.expand()
torch.distributions.cauchy.Cauchy.has_rsample
torch.distributions.cauchy.Cauchy.icdf()
torch.distributions.cauchy.Cauchy.log_prob()
torch.distributions.cauchy.Cauchy.mean()
torch.distributions.cauchy.Cauchy.rsample()
torch.distributions.cauchy.Cauchy.support
torch.distributions.cauchy.Cauchy.variance()
torch.distributions.chi2.Chi2
torch.distributions.chi2.Chi2.arg_constraints
torch.distributions.chi2.Chi2.df()
torch.distributions.chi2.Chi2.expand()
torch.distributions.constraint_registry.ConstraintRegistry
torch.distributions.constraint_registry.ConstraintRegistry.register()
torch.distributions.constraints.Constraint
torch.distributions.constraints.Constraint.check()
torch.distributions.constraints.cat
torch.distributions.constraints.dependent_property
torch.distributions.constraints.greater_than
torch.distributions.constraints.greater_than_eq
torch.distributions.constraints.half_open_interval
torch.distributions.constraints.independent
torch.distributions.constraints.integer_interval
torch.distributions.constraints.interval
torch.distributions.constraints.less_than
torch.distributions.constraints.multinomial
torch.distributions.constraints.stack
torch.distributions.continuous_bernoulli.ContinuousBernoulli
torch.distributions.continuous_bernoulli.ContinuousBernoulli.arg_constraints
torch.distributions.continuous_bernoulli.ContinuousBernoulli.cdf()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.entropy()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.expand()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.has_rsample
torch.distributions.continuous_bernoulli.ContinuousBernoulli.icdf()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.log_prob()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.logits
torch.distributions.continuous_bernoulli.ContinuousBernoulli.mean()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.param_shape()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.probs
torch.distributions.continuous_bernoulli.ContinuousBernoulli.rsample()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.sample()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.stddev()
torch.distributions.continuous_bernoulli.ContinuousBernoulli.support
torch.distributions.continuous_bernoulli.ContinuousBernoulli.variance()
torch.distributions.dirichlet.Dirichlet
torch.distributions.dirichlet.Dirichlet.arg_constraints
torch.distributions.dirichlet.Dirichlet.entropy()
torch.distributions.dirichlet.Dirichlet.expand()
torch.distributions.dirichlet.Dirichlet.has_rsample
torch.distributions.dirichlet.Dirichlet.log_prob()
torch.distributions.dirichlet.Dirichlet.mean()
torch.distributions.dirichlet.Dirichlet.rsample()
torch.distributions.dirichlet.Dirichlet.support
torch.distributions.dirichlet.Dirichlet.variance()
torch.distributions.distribution.Distribution
torch.distributions.distribution.Distribution.arg_constraints()
torch.distributions.distribution.Distribution.batch_shape()
torch.distributions.distribution.Distribution.cdf()
torch.distributions.distribution.Distribution.entropy()
torch.distributions.distribution.Distribution.enumerate_support()
torch.distributions.distribution.Distribution.event_shape()
torch.distributions.distribution.Distribution.expand()
torch.distributions.distribution.Distribution.icdf()
torch.distributions.distribution.Distribution.log_prob()
torch.distributions.distribution.Distribution.mean()
torch.distributions.distribution.Distribution.perplexity()
torch.distributions.distribution.Distribution.rsample()
torch.distributions.distribution.Distribution.sample()
torch.distributions.distribution.Distribution.sample_n()
torch.distributions.distribution.Distribution.set_default_validate_args()
torch.distributions.distribution.Distribution.stddev()
torch.distributions.distribution.Distribution.support()
torch.distributions.distribution.Distribution.variance()
torch.distributions.exp_family.ExponentialFamily
torch.distributions.exp_family.ExponentialFamily.entropy()
torch.distributions.exponential.Exponential
torch.distributions.exponential.Exponential.arg_constraints
torch.distributions.exponential.Exponential.cdf()
torch.distributions.exponential.Exponential.entropy()
torch.distributions.exponential.Exponential.expand()
torch.distributions.exponential.Exponential.has_rsample
torch.distributions.exponential.Exponential.icdf()
torch.distributions.exponential.Exponential.log_prob()
torch.distributions.exponential.Exponential.mean()
torch.distributions.exponential.Exponential.rsample()
torch.distributions.exponential.Exponential.stddev()
torch.distributions.exponential.Exponential.support
torch.distributions.exponential.Exponential.variance()
torch.distributions.fishersnedecor.FisherSnedecor
torch.distributions.fishersnedecor.FisherSnedecor.arg_constraints
torch.distributions.fishersnedecor.FisherSnedecor.expand()
torch.distributions.fishersnedecor.FisherSnedecor.has_rsample
torch.distributions.fishersnedecor.FisherSnedecor.log_prob()
torch.distributions.fishersnedecor.FisherSnedecor.mean()
torch.distributions.fishersnedecor.FisherSnedecor.rsample()
torch.distributions.fishersnedecor.FisherSnedecor.support
torch.distributions.fishersnedecor.FisherSnedecor.variance()
torch.distributions.gamma.Gamma
torch.distributions.gamma.Gamma.arg_constraints
torch.distributions.gamma.Gamma.entropy()
torch.distributions.gamma.Gamma.expand()
torch.distributions.gamma.Gamma.has_rsample
torch.distributions.gamma.Gamma.log_prob()
torch.distributions.gamma.Gamma.mean()
torch.distributions.gamma.Gamma.rsample()
torch.distributions.gamma.Gamma.support
torch.distributions.gamma.Gamma.variance()
torch.distributions.geometric.Geometric
torch.distributions.geometric.Geometric.arg_constraints
torch.distributions.geometric.Geometric.entropy()
torch.distributions.geometric.Geometric.expand()
torch.distributions.geometric.Geometric.log_prob()
torch.distributions.geometric.Geometric.logits
torch.distributions.geometric.Geometric.mean()
torch.distributions.geometric.Geometric.probs
torch.distributions.geometric.Geometric.sample()
torch.distributions.geometric.Geometric.support
torch.distributions.geometric.Geometric.variance()
torch.distributions.gumbel.Gumbel
torch.distributions.gumbel.Gumbel.arg_constraints
torch.distributions.gumbel.Gumbel.entropy()
torch.distributions.gumbel.Gumbel.expand()
torch.distributions.gumbel.Gumbel.log_prob()
torch.distributions.gumbel.Gumbel.mean()
torch.distributions.gumbel.Gumbel.stddev()
torch.distributions.gumbel.Gumbel.support
torch.distributions.gumbel.Gumbel.variance()
torch.distributions.half_cauchy.HalfCauchy
torch.distributions.half_cauchy.HalfCauchy.arg_constraints
torch.distributions.half_cauchy.HalfCauchy.cdf()
torch.distributions.half_cauchy.HalfCauchy.entropy()
torch.distributions.half_cauchy.HalfCauchy.expand()
torch.distributions.half_cauchy.HalfCauchy.has_rsample
torch.distributions.half_cauchy.HalfCauchy.icdf()
torch.distributions.half_cauchy.HalfCauchy.log_prob()
torch.distributions.half_cauchy.HalfCauchy.mean()
torch.distributions.half_cauchy.HalfCauchy.scale()
torch.distributions.half_cauchy.HalfCauchy.support
torch.distributions.half_cauchy.HalfCauchy.variance()
torch.distributions.half_normal.HalfNormal
torch.distributions.half_normal.HalfNormal.arg_constraints
torch.distributions.half_normal.HalfNormal.cdf()
torch.distributions.half_normal.HalfNormal.entropy()
torch.distributions.half_normal.HalfNormal.expand()
torch.distributions.half_normal.HalfNormal.has_rsample
torch.distributions.half_normal.HalfNormal.icdf()
torch.distributions.half_normal.HalfNormal.log_prob()
torch.distributions.half_normal.HalfNormal.mean()
torch.distributions.half_normal.HalfNormal.scale()
torch.distributions.half_normal.HalfNormal.support
torch.distributions.half_normal.HalfNormal.variance()
torch.distributions.independent.Independent
torch.distributions.independent.Independent.arg_constraints
torch.distributions.independent.Independent.entropy()
torch.distributions.independent.Independent.enumerate_support()
torch.distributions.independent.Independent.expand()
torch.distributions.independent.Independent.has_enumerate_support()
torch.distributions.independent.Independent.has_rsample()
torch.distributions.independent.Independent.log_prob()
torch.distributions.independent.Independent.mean()
torch.distributions.independent.Independent.rsample()
torch.distributions.independent.Independent.sample()
torch.distributions.independent.Independent.support()
torch.distributions.independent.Independent.variance()
torch.distributions.kl.kl_divergence()
torch.distributions.kl.register_kl()
torch.distributions.kumaraswamy.Kumaraswamy
torch.distributions.kumaraswamy.Kumaraswamy.arg_constraints
torch.distributions.kumaraswamy.Kumaraswamy.entropy()
torch.distributions.kumaraswamy.Kumaraswamy.expand()
torch.distributions.kumaraswamy.Kumaraswamy.has_rsample
torch.distributions.kumaraswamy.Kumaraswamy.mean()
torch.distributions.kumaraswamy.Kumaraswamy.support
torch.distributions.kumaraswamy.Kumaraswamy.variance()
torch.distributions.laplace.Laplace
torch.distributions.laplace.Laplace.arg_constraints
torch.distributions.laplace.Laplace.cdf()
torch.distributions.laplace.Laplace.entropy()
torch.distributions.laplace.Laplace.expand()
torch.distributions.laplace.Laplace.has_rsample
torch.distributions.laplace.Laplace.icdf()
torch.distributions.laplace.Laplace.log_prob()
torch.distributions.laplace.Laplace.mean()
torch.distributions.laplace.Laplace.rsample()
torch.distributions.laplace.Laplace.stddev()
torch.distributions.laplace.Laplace.support
torch.distributions.laplace.Laplace.variance()
torch.distributions.lkj_cholesky.LKJCholesky
torch.distributions.lkj_cholesky.LKJCholesky.arg_constraints
torch.distributions.lkj_cholesky.LKJCholesky.expand()
torch.distributions.lkj_cholesky.LKJCholesky.log_prob()
torch.distributions.lkj_cholesky.LKJCholesky.sample()
torch.distributions.lkj_cholesky.LKJCholesky.support
torch.distributions.log_normal.LogNormal
torch.distributions.log_normal.LogNormal.arg_constraints
torch.distributions.log_normal.LogNormal.entropy()
torch.distributions.log_normal.LogNormal.expand()
torch.distributions.log_normal.LogNormal.has_rsample
torch.distributions.log_normal.LogNormal.loc()
torch.distributions.log_normal.LogNormal.mean()
torch.distributions.log_normal.LogNormal.scale()
torch.distributions.log_normal.LogNormal.support
torch.distributions.log_normal.LogNormal.variance()
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.arg_constraints
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.covariance_matrix
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.entropy()
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.expand()
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.has_rsample
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.log_prob()
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.mean()
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.precision_matrix
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.rsample()
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.scale_tril
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.support
torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.variance
torch.distributions.mixture_same_family.MixtureSameFamily
torch.distributions.mixture_same_family.MixtureSameFamily.arg_constraints
torch.distributions.mixture_same_family.MixtureSameFamily.cdf()
torch.distributions.mixture_same_family.MixtureSameFamily.component_distribution()
torch.distributions.mixture_same_family.MixtureSameFamily.expand()
torch.distributions.mixture_same_family.MixtureSameFamily.has_rsample
torch.distributions.mixture_same_family.MixtureSameFamily.log_prob()
torch.distributions.mixture_same_family.MixtureSameFamily.mean()
torch.distributions.mixture_same_family.MixtureSameFamily.mixture_distribution()
torch.distributions.mixture_same_family.MixtureSameFamily.sample()
torch.distributions.mixture_same_family.MixtureSameFamily.support()
torch.distributions.mixture_same_family.MixtureSameFamily.variance()
torch.distributions.multinomial.Multinomial
torch.distributions.multinomial.Multinomial.arg_constraints
torch.distributions.multinomial.Multinomial.expand()
torch.distributions.multinomial.Multinomial.log_prob()
torch.distributions.multinomial.Multinomial.logits()
torch.distributions.multinomial.Multinomial.mean()
torch.distributions.multinomial.Multinomial.param_shape()
torch.distributions.multinomial.Multinomial.probs()
torch.distributions.multinomial.Multinomial.sample()
torch.distributions.multinomial.Multinomial.support()
torch.distributions.multinomial.Multinomial.total_count
torch.distributions.multinomial.Multinomial.variance()
torch.distributions.multivariate_normal.MultivariateNormal
torch.distributions.multivariate_normal.MultivariateNormal.arg_constraints
torch.distributions.multivariate_normal.MultivariateNormal.covariance_matrix
torch.distributions.multivariate_normal.MultivariateNormal.entropy()
torch.distributions.multivariate_normal.MultivariateNormal.expand()
torch.distributions.multivariate_normal.MultivariateNormal.has_rsample
torch.distributions.multivariate_normal.MultivariateNormal.log_prob()
torch.distributions.multivariate_normal.MultivariateNormal.mean()
torch.distributions.multivariate_normal.MultivariateNormal.precision_matrix
torch.distributions.multivariate_normal.MultivariateNormal.rsample()
torch.distributions.multivariate_normal.MultivariateNormal.scale_tril
torch.distributions.multivariate_normal.MultivariateNormal.support
torch.distributions.multivariate_normal.MultivariateNormal.variance()
torch.distributions.negative_binomial.NegativeBinomial
torch.distributions.negative_binomial.NegativeBinomial.arg_constraints
torch.distributions.negative_binomial.NegativeBinomial.expand()
torch.distributions.negative_binomial.NegativeBinomial.log_prob()
torch.distributions.negative_binomial.NegativeBinomial.logits
torch.distributions.negative_binomial.NegativeBinomial.mean()
torch.distributions.negative_binomial.NegativeBinomial.param_shape()
torch.distributions.negative_binomial.NegativeBinomial.probs
torch.distributions.negative_binomial.NegativeBinomial.sample()
torch.distributions.negative_binomial.NegativeBinomial.support
torch.distributions.negative_binomial.NegativeBinomial.variance()
torch.distributions.normal.Normal
torch.distributions.normal.Normal.arg_constraints
torch.distributions.normal.Normal.cdf()
torch.distributions.normal.Normal.entropy()
torch.distributions.normal.Normal.expand()
torch.distributions.normal.Normal.has_rsample
torch.distributions.normal.Normal.icdf()
torch.distributions.normal.Normal.log_prob()
torch.distributions.normal.Normal.mean()
torch.distributions.normal.Normal.rsample()
torch.distributions.normal.Normal.sample()
torch.distributions.normal.Normal.stddev()
torch.distributions.normal.Normal.support
torch.distributions.normal.Normal.variance()
torch.distributions.one_hot_categorical.OneHotCategorical
torch.distributions.one_hot_categorical.OneHotCategorical.arg_constraints
torch.distributions.one_hot_categorical.OneHotCategorical.entropy()
torch.distributions.one_hot_categorical.OneHotCategorical.enumerate_support()
torch.distributions.one_hot_categorical.OneHotCategorical.expand()
torch.distributions.one_hot_categorical.OneHotCategorical.has_enumerate_support
torch.distributions.one_hot_categorical.OneHotCategorical.log_prob()
torch.distributions.one_hot_categorical.OneHotCategorical.logits()
torch.distributions.one_hot_categorical.OneHotCategorical.mean()
torch.distributions.one_hot_categorical.OneHotCategorical.param_shape()
torch.distributions.one_hot_categorical.OneHotCategorical.probs()
torch.distributions.one_hot_categorical.OneHotCategorical.sample()
torch.distributions.one_hot_categorical.OneHotCategorical.support
torch.distributions.one_hot_categorical.OneHotCategorical.variance()
torch.distributions.pareto.Pareto
torch.distributions.pareto.Pareto.arg_constraints
torch.distributions.pareto.Pareto.entropy()
torch.distributions.pareto.Pareto.expand()
torch.distributions.pareto.Pareto.mean()
torch.distributions.pareto.Pareto.support()
torch.distributions.pareto.Pareto.variance()
torch.distributions.poisson.Poisson
torch.distributions.poisson.Poisson.arg_constraints
torch.distributions.poisson.Poisson.expand()
torch.distributions.poisson.Poisson.log_prob()
torch.distributions.poisson.Poisson.mean()
torch.distributions.poisson.Poisson.sample()
torch.distributions.poisson.Poisson.support
torch.distributions.poisson.Poisson.variance()
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.arg_constraints
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.expand()
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.log_prob()
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.logits
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.param_shape()
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.probs
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.rsample()
torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.support
torch.distributions.relaxed_bernoulli.RelaxedBernoulli
torch.distributions.relaxed_bernoulli.RelaxedBernoulli.arg_constraints
torch.distributions.relaxed_bernoulli.RelaxedBernoulli.expand()
torch.distributions.relaxed_bernoulli.RelaxedBernoulli.has_rsample
torch.distributions.relaxed_bernoulli.RelaxedBernoulli.logits()
torch.distributions.relaxed_bernoulli.RelaxedBernoulli.probs()
torch.distributions.relaxed_bernoulli.RelaxedBernoulli.support
torch.distributions.relaxed_bernoulli.RelaxedBernoulli.temperature()
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.arg_constraints
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.expand()
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.has_rsample
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.logits()
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.probs()
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.support
torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.temperature()
torch.distributions.studentT.StudentT
torch.distributions.studentT.StudentT.arg_constraints
torch.distributions.studentT.StudentT.entropy()
torch.distributions.studentT.StudentT.expand()
torch.distributions.studentT.StudentT.has_rsample
torch.distributions.studentT.StudentT.log_prob()
torch.distributions.studentT.StudentT.mean()
torch.distributions.studentT.StudentT.rsample()
torch.distributions.studentT.StudentT.support
torch.distributions.studentT.StudentT.variance()
torch.distributions.transformed_distribution.TransformedDistribution
torch.distributions.transformed_distribution.TransformedDistribution.arg_constraints
torch.distributions.transformed_distribution.TransformedDistribution.cdf()
torch.distributions.transformed_distribution.TransformedDistribution.expand()
torch.distributions.transformed_distribution.TransformedDistribution.has_rsample()
torch.distributions.transformed_distribution.TransformedDistribution.icdf()
torch.distributions.transformed_distribution.TransformedDistribution.log_prob()
torch.distributions.transformed_distribution.TransformedDistribution.rsample()
torch.distributions.transformed_distribution.TransformedDistribution.sample()
torch.distributions.transformed_distribution.TransformedDistribution.support()
torch.distributions.transforms.AbsTransform
torch.distributions.transforms.AffineTransform
torch.distributions.transforms.ComposeTransform
torch.distributions.transforms.CorrCholeskyTransform
torch.distributions.transforms.ExpTransform
torch.distributions.transforms.IndependentTransform
torch.distributions.transforms.LowerCholeskyTransform
torch.distributions.transforms.PowerTransform
torch.distributions.transforms.ReshapeTransform
torch.distributions.transforms.SigmoidTransform
torch.distributions.transforms.SoftmaxTransform
torch.distributions.transforms.StackTransform
torch.distributions.transforms.StickBreakingTransform
torch.distributions.transforms.TanhTransform
torch.distributions.transforms.Transform
torch.distributions.transforms.Transform.forward_shape()
torch.distributions.transforms.Transform.inv()
torch.distributions.transforms.Transform.inverse_shape()
torch.distributions.transforms.Transform.log_abs_det_jacobian()
torch.distributions.transforms.Transform.sign()
torch.distributions.uniform.Uniform
torch.distributions.uniform.Uniform.arg_constraints
torch.distributions.uniform.Uniform.cdf()
torch.distributions.uniform.Uniform.entropy()
torch.distributions.uniform.Uniform.expand()
torch.distributions.uniform.Uniform.has_rsample
torch.distributions.uniform.Uniform.icdf()
torch.distributions.uniform.Uniform.log_prob()
torch.distributions.uniform.Uniform.mean()
torch.distributions.uniform.Uniform.rsample()
torch.distributions.uniform.Uniform.stddev()
torch.distributions.uniform.Uniform.support()
torch.distributions.uniform.Uniform.variance()
torch.distributions.von_mises.VonMises
torch.distributions.von_mises.VonMises.arg_constraints
torch.distributions.von_mises.VonMises.expand()
torch.distributions.von_mises.VonMises.has_rsample
torch.distributions.von_mises.VonMises.log_prob()
torch.distributions.von_mises.VonMises.mean()
torch.distributions.von_mises.VonMises.sample()
torch.distributions.von_mises.VonMises.support
torch.distributions.von_mises.VonMises.variance
torch.distributions.weibull.Weibull
torch.distributions.weibull.Weibull.arg_constraints
torch.distributions.weibull.Weibull.entropy()
torch.distributions.weibull.Weibull.expand()
torch.distributions.weibull.Weibull.mean()
torch.distributions.weibull.Weibull.support
torch.distributions.weibull.Weibull.variance()
torch.fft
torch.fft
torch.fft.fft()
torch.fft.fft2()
torch.fft.fftfreq()
torch.fft.fftn()
torch.fft.fftshift()
torch.fft.hfft()
torch.fft.ifft()
torch.fft.ifft2()
torch.fft.ifftn()
torch.fft.ifftshift()
torch.fft.ihfft()
torch.fft.irfft()
torch.fft.irfft2()
torch.fft.irfftn()
torch.fft.rfft()
torch.fft.rfft2()
torch.fft.rfftfreq()
torch.fft.rfftn()
torch.Storage
torch.FloatStorage
torch.FloatStorage.bfloat16()
torch.FloatStorage.bool()
torch.FloatStorage.byte()
torch.FloatStorage.char()
torch.FloatStorage.clone()
torch.FloatStorage.complex_double()
torch.FloatStorage.complex_float()
torch.FloatStorage.copy_()
torch.FloatStorage.cpu()
torch.FloatStorage.cuda()
torch.FloatStorage.data_ptr()
torch.FloatStorage.device
torch.FloatStorage.double()
torch.FloatStorage.dtype
torch.FloatStorage.element_size()
torch.FloatStorage.fill_()
torch.FloatStorage.float()
torch.FloatStorage.from_buffer()
torch.FloatStorage.from_file()
torch.FloatStorage.get_device()
torch.FloatStorage.half()
torch.FloatStorage.int()
torch.FloatStorage.is_cuda
torch.FloatStorage.is_pinned()
torch.FloatStorage.is_shared()
torch.FloatStorage.is_sparse
torch.FloatStorage.long()
torch.FloatStorage.new()
torch.FloatStorage.pin_memory()
torch.FloatStorage.resize_()
torch.FloatStorage.share_memory_()
torch.FloatStorage.short()
torch.FloatStorage.size()
torch.FloatStorage.tolist()
torch.FloatStorage.type()
torch.Storage
torch.futures
torch.futures
torch.futures.Future
torch.futures.Future.add_done_callback()
torch.futures.Future.done()
torch.futures.Future.set_exception()
torch.futures.Future.set_result()
torch.futures.Future.then()
torch.futures.Future.value()
torch.futures.Future.wait()
torch.futures.collect_all()
torch.futures.wait_all()
torch.fx
torch.fx
torch.fx.Graph
torch.fx.Graph.__init__()
torch.fx.Graph.call_function()
torch.fx.Graph.call_method()
torch.fx.Graph.call_module()
torch.fx.Graph.create_node()
torch.fx.Graph.erase_node()
torch.fx.Graph.get_attr()
torch.fx.Graph.graph_copy()
torch.fx.Graph.inserting_after()
torch.fx.Graph.inserting_before()
torch.fx.Graph.lint()
torch.fx.Graph.node_copy()
torch.fx.Graph.nodes()
torch.fx.Graph.output()
torch.fx.Graph.placeholder()
torch.fx.Graph.print_tabular()
torch.fx.Graph.python_code()
torch.fx.GraphModule
torch.fx.GraphModule.__init__()
torch.fx.GraphModule.code()
torch.fx.GraphModule.graph()
torch.fx.GraphModule.recompile()
torch.fx.GraphModule.to_folder()
torch.fx.Interpreter
torch.fx.Interpreter.call_function()
torch.fx.Interpreter.call_method()
torch.fx.Interpreter.call_module()
torch.fx.Interpreter.fetch_args_kwargs_from_env()
torch.fx.Interpreter.fetch_attr()
torch.fx.Interpreter.get_attr()
torch.fx.Interpreter.map_nodes_to_values()
torch.fx.Interpreter.output()
torch.fx.Interpreter.placeholder()
torch.fx.Interpreter.run()
torch.fx.Interpreter.run_node()
torch.fx.Node
torch.fx.Node.all_input_nodes()
torch.fx.Node.append()
torch.fx.Node.args()
torch.fx.Node.kwargs()
torch.fx.Node.next()
torch.fx.Node.prepend()
torch.fx.Node.prev()
torch.fx.Node.replace_all_uses_with()
torch.fx.Proxy
torch.fx.Tracer
torch.fx.Tracer.call_module()
torch.fx.Tracer.create_arg()
torch.fx.Tracer.create_args_for_root()
torch.fx.Tracer.is_leaf_module()
torch.fx.Tracer.path_of_module()
torch.fx.Tracer.trace()
torch.fx.Transformer
torch.fx.Transformer.get_attr()
torch.fx.Transformer.placeholder()
torch.fx.Transformer.transform()
torch.fx.replace_pattern()
torch.fx.symbolic_trace()
torch.fx.wrap()
torch.sparse
torch.Tensor.coalesce()
torch.Tensor.dense_dim()
torch.Tensor.indices()
torch.Tensor.is_coalesced()
torch.Tensor.is_sparse
torch.Tensor.sparse_dim()
torch.Tensor.sparse_mask()
torch.Tensor.sparse_resize_()
torch.Tensor.sparse_resize_and_clear_()
torch.Tensor.to_dense()
torch.Tensor.to_sparse()
torch.Tensor.values()
torch.hspmm()
torch.smm()
torch.sparse
torch.sparse.addmm()
torch.sparse.log_softmax()
torch.sparse.mm()
torch.sparse.softmax()
torch.sparse.sum()
torch.sspaddmm()
torch.hub
torch.hub
torch.hub.download_url_to_file()
torch.hub.get_dir()
torch.hub.help()
torch.hub.list()
torch.hub.load()
torch.hub.load_state_dict_from_url()
torch.hub.set_dir()
TorchScript
torch.jit.ScriptFunction
torch.jit.ScriptFunction.get_debug_state()
torch.jit.ScriptFunction.save()
torch.jit.ScriptFunction.save_to_buffer()
torch.jit.ScriptModule
torch.jit.ScriptModule.add_module()
torch.jit.ScriptModule.apply()
torch.jit.ScriptModule.bfloat16()
torch.jit.ScriptModule.buffers()
torch.jit.ScriptModule.children()
torch.jit.ScriptModule.code()
torch.jit.ScriptModule.code_with_constants()
torch.jit.ScriptModule.cpu()
torch.jit.ScriptModule.cuda()
torch.jit.ScriptModule.double()
torch.jit.ScriptModule.eval()
torch.jit.ScriptModule.extra_repr()
torch.jit.ScriptModule.float()
torch.jit.ScriptModule.graph()
torch.jit.ScriptModule.half()
torch.jit.ScriptModule.inlined_graph()
torch.jit.ScriptModule.load_state_dict()
torch.jit.ScriptModule.modules()
torch.jit.ScriptModule.named_buffers()
torch.jit.ScriptModule.named_children()
torch.jit.ScriptModule.named_modules()
torch.jit.ScriptModule.named_parameters()
torch.jit.ScriptModule.parameters()
torch.jit.ScriptModule.register_backward_hook()
torch.jit.ScriptModule.register_buffer()
torch.jit.ScriptModule.register_forward_hook()
torch.jit.ScriptModule.register_forward_pre_hook()
torch.jit.ScriptModule.register_full_backward_hook()
torch.jit.ScriptModule.register_parameter()
torch.jit.ScriptModule.requires_grad_()
torch.jit.ScriptModule.save()
torch.jit.ScriptModule.state_dict()
torch.jit.ScriptModule.to()
torch.jit.ScriptModule.train()
torch.jit.ScriptModule.type()
torch.jit.ScriptModule.xpu()
torch.jit.ScriptModule.zero_grad()
torch.jit.export()
torch.jit.fork()
torch.jit.freeze()
torch.jit.ignore()
torch.jit.is_scripting()
torch.jit.isinstance()
torch.jit.load()
torch.jit.save()
torch.jit.script()
torch.jit.script_if_tracing()
torch.jit.trace()
torch.jit.trace_module()
torch.jit.unused()
torch.jit.wait()
torch.linalg
torch.linalg
torch.linalg.cholesky()
torch.linalg.cond()
torch.linalg.det()
torch.linalg.eigh()
torch.linalg.eigvalsh()
torch.linalg.inv()
torch.linalg.matrix_rank()
torch.linalg.norm()
torch.linalg.pinv()
torch.linalg.qr()
torch.linalg.slogdet()
torch.linalg.solve()
torch.linalg.svd()
torch.linalg.tensorinv()
torch.linalg.tensorsolve()
torch.multiprocessing
torch.multiprocessing
torch.multiprocessing.SpawnContext
torch.multiprocessing.SpawnContext.join()
torch.multiprocessing.get_all_sharing_strategies()
torch.multiprocessing.get_sharing_strategy()
torch.multiprocessing.set_sharing_strategy()
torch.multiprocessing.spawn()
torch.nn
torch.nn
torch.nn.AdaptiveAvgPool1d
torch.nn.AdaptiveAvgPool2d
torch.nn.AdaptiveAvgPool3d
torch.nn.AdaptiveLogSoftmaxWithLoss
torch.nn.AdaptiveLogSoftmaxWithLoss.log_prob()
torch.nn.AdaptiveLogSoftmaxWithLoss.predict()
torch.nn.AdaptiveMaxPool1d
torch.nn.AdaptiveMaxPool2d
torch.nn.AdaptiveMaxPool3d
torch.nn.AlphaDropout
torch.nn.AvgPool1d
torch.nn.AvgPool2d
torch.nn.AvgPool3d
torch.nn.BCELoss
torch.nn.BCEWithLogitsLoss
torch.nn.BatchNorm1d
torch.nn.BatchNorm2d
torch.nn.BatchNorm3d
torch.nn.Bilinear
torch.nn.CELU
torch.nn.CTCLoss
torch.nn.ChannelShuffle
torch.nn.ConstantPad1d
torch.nn.ConstantPad2d
torch.nn.ConstantPad3d
torch.nn.Conv1d
torch.nn.Conv2d
torch.nn.Conv3d
torch.nn.ConvTranspose1d
torch.nn.ConvTranspose2d
torch.nn.ConvTranspose3d
torch.nn.CosineEmbeddingLoss
torch.nn.CosineSimilarity
torch.nn.CrossEntropyLoss
torch.nn.DataParallel
torch.nn.Dropout
torch.nn.Dropout2d
torch.nn.Dropout3d
torch.nn.ELU
torch.nn.Embedding
torch.nn.Embedding.from_pretrained()
torch.nn.EmbeddingBag
torch.nn.EmbeddingBag.from_pretrained()
torch.nn.Flatten
torch.nn.Flatten.add_module()
torch.nn.Flatten.apply()
torch.nn.Flatten.bfloat16()
torch.nn.Flatten.buffers()
torch.nn.Flatten.children()
torch.nn.Flatten.cpu()
torch.nn.Flatten.cuda()
torch.nn.Flatten.double()
torch.nn.Flatten.eval()
torch.nn.Flatten.float()
torch.nn.Flatten.half()
torch.nn.Flatten.load_state_dict()
torch.nn.Flatten.modules()
torch.nn.Flatten.named_buffers()
torch.nn.Flatten.named_children()
torch.nn.Flatten.named_modules()
torch.nn.Flatten.named_parameters()
torch.nn.Flatten.parameters()
torch.nn.Flatten.register_backward_hook()
torch.nn.Flatten.register_buffer()
torch.nn.Flatten.register_forward_hook()
torch.nn.Flatten.register_forward_pre_hook()
torch.nn.Flatten.register_full_backward_hook()
torch.nn.Flatten.register_parameter()
torch.nn.Flatten.requires_grad_()
torch.nn.Flatten.state_dict()
torch.nn.Flatten.to()
torch.nn.Flatten.train()
torch.nn.Flatten.type()
torch.nn.Flatten.xpu()
torch.nn.Flatten.zero_grad()
torch.nn.Fold
torch.nn.FractionalMaxPool2d
torch.nn.GELU
torch.nn.GRU
torch.nn.GRUCell
torch.nn.GaussianNLLLoss
torch.nn.GroupNorm
torch.nn.Hardshrink
torch.nn.Hardsigmoid
torch.nn.Hardswish
torch.nn.Hardtanh
torch.nn.HingeEmbeddingLoss
torch.nn.Identity
torch.nn.InstanceNorm1d
torch.nn.InstanceNorm2d
torch.nn.InstanceNorm3d
torch.nn.KLDivLoss
torch.nn.L1Loss
torch.nn.LPPool1d
torch.nn.LPPool2d
torch.nn.LSTM
torch.nn.LSTMCell
torch.nn.LayerNorm
torch.nn.LazyConv1d
torch.nn.LazyConv1d.cls_to_become
torch.nn.LazyConv2d
torch.nn.LazyConv2d.cls_to_become
torch.nn.LazyConv3d
torch.nn.LazyConv3d.cls_to_become
torch.nn.LazyConvTranspose1d
torch.nn.LazyConvTranspose1d.cls_to_become
torch.nn.LazyConvTranspose2d
torch.nn.LazyConvTranspose2d.cls_to_become
torch.nn.LazyConvTranspose3d
torch.nn.LazyConvTranspose3d.cls_to_become
torch.nn.LazyLinear
torch.nn.LazyLinear.cls_to_become
torch.nn.LeakyReLU
torch.nn.Linear
torch.nn.LocalResponseNorm
torch.nn.LogSigmoid
torch.nn.LogSoftmax
torch.nn.MSELoss
torch.nn.MarginRankingLoss
torch.nn.MaxPool1d
torch.nn.MaxPool2d
torch.nn.MaxPool3d
torch.nn.MaxUnpool1d
torch.nn.MaxUnpool2d
torch.nn.MaxUnpool3d
torch.nn.Module
torch.nn.Module.add_module()
torch.nn.Module.apply()
torch.nn.Module.bfloat16()
torch.nn.Module.buffers()
torch.nn.Module.children()
torch.nn.Module.cpu()
torch.nn.Module.cuda()
torch.nn.Module.double()
torch.nn.Module.dump_patches
torch.nn.Module.eval()
torch.nn.Module.extra_repr()
torch.nn.Module.float()
torch.nn.Module.forward()
torch.nn.Module.half()
torch.nn.Module.load_state_dict()
torch.nn.Module.modules()
torch.nn.Module.named_buffers()
torch.nn.Module.named_children()
torch.nn.Module.named_modules()
torch.nn.Module.named_parameters()
torch.nn.Module.parameters()
torch.nn.Module.register_backward_hook()
torch.nn.Module.register_buffer()
torch.nn.Module.register_forward_hook()
torch.nn.Module.register_forward_pre_hook()
torch.nn.Module.register_full_backward_hook()
torch.nn.Module.register_parameter()
torch.nn.Module.requires_grad_()
torch.nn.Module.state_dict()
torch.nn.Module.to()
torch.nn.Module.train()
torch.nn.Module.type()
torch.nn.Module.xpu()
torch.nn.Module.zero_grad()
torch.nn.ModuleDict
torch.nn.ModuleDict.clear()
torch.nn.ModuleDict.items()
torch.nn.ModuleDict.keys()
torch.nn.ModuleDict.pop()
torch.nn.ModuleDict.update()
torch.nn.ModuleDict.values()
torch.nn.ModuleList
torch.nn.ModuleList.append()
torch.nn.ModuleList.extend()
torch.nn.ModuleList.insert()
torch.nn.MultiLabelMarginLoss
torch.nn.MultiLabelSoftMarginLoss
torch.nn.MultiMarginLoss
torch.nn.MultiheadAttention
torch.nn.MultiheadAttention.forward()
torch.nn.NLLLoss
torch.nn.PReLU
torch.nn.PairwiseDistance
torch.nn.ParameterDict
torch.nn.ParameterDict.clear()
torch.nn.ParameterDict.items()
torch.nn.ParameterDict.keys()
torch.nn.ParameterDict.pop()
torch.nn.ParameterDict.update()
torch.nn.ParameterDict.values()
torch.nn.ParameterList
torch.nn.ParameterList.append()
torch.nn.ParameterList.extend()
torch.nn.PixelShuffle
torch.nn.PixelUnshuffle
torch.nn.PoissonNLLLoss
torch.nn.RNN
torch.nn.RNNBase
torch.nn.RNNBase.flatten_parameters()
torch.nn.RNNCell
torch.nn.RReLU
torch.nn.ReLU
torch.nn.ReLU6
torch.nn.ReflectionPad1d
torch.nn.ReflectionPad2d
torch.nn.ReplicationPad1d
torch.nn.ReplicationPad2d
torch.nn.ReplicationPad3d
torch.nn.SELU
torch.nn.Sequential
torch.nn.SiLU
torch.nn.Sigmoid
torch.nn.SmoothL1Loss
torch.nn.SoftMarginLoss
torch.nn.Softmax
torch.nn.Softmax2d
torch.nn.Softmin
torch.nn.Softplus
torch.nn.Softshrink
torch.nn.Softsign
torch.nn.SyncBatchNorm
torch.nn.SyncBatchNorm.convert_sync_batchnorm()
torch.nn.Tanh
torch.nn.Tanhshrink
torch.nn.Threshold
torch.nn.Transformer
torch.nn.Transformer.forward()
torch.nn.Transformer.generate_square_subsequent_mask()
torch.nn.TransformerDecoder
torch.nn.TransformerDecoder.forward()
torch.nn.TransformerDecoderLayer
torch.nn.TransformerDecoderLayer.forward()
torch.nn.TransformerEncoder
torch.nn.TransformerEncoder.forward()
torch.nn.TransformerEncoderLayer
torch.nn.TransformerEncoderLayer.forward()
torch.nn.TripletMarginLoss
torch.nn.TripletMarginWithDistanceLoss
torch.nn.Unflatten
torch.nn.Unflatten.add_module()
torch.nn.Unflatten.apply()
torch.nn.Unflatten.bfloat16()
torch.nn.Unflatten.buffers()
torch.nn.Unflatten.children()
torch.nn.Unflatten.cpu()
torch.nn.Unflatten.cuda()
torch.nn.Unflatten.double()
torch.nn.Unflatten.eval()
torch.nn.Unflatten.float()
torch.nn.Unflatten.half()
torch.nn.Unflatten.load_state_dict()
torch.nn.Unflatten.modules()
torch.nn.Unflatten.named_buffers()
torch.nn.Unflatten.named_children()
torch.nn.Unflatten.named_modules()
torch.nn.Unflatten.named_parameters()
torch.nn.Unflatten.parameters()
torch.nn.Unflatten.register_backward_hook()
torch.nn.Unflatten.register_buffer()
torch.nn.Unflatten.register_forward_hook()
torch.nn.Unflatten.register_forward_pre_hook()
torch.nn.Unflatten.register_full_backward_hook()
torch.nn.Unflatten.register_parameter()
torch.nn.Unflatten.requires_grad_()
torch.nn.Unflatten.state_dict()
torch.nn.Unflatten.to()
torch.nn.Unflatten.train()
torch.nn.Unflatten.type()
torch.nn.Unflatten.xpu()
torch.nn.Unflatten.zero_grad()
torch.nn.Unfold
torch.nn.Upsample
torch.nn.UpsamplingBilinear2d
torch.nn.UpsamplingNearest2d
torch.nn.ZeroPad2d
torch.nn.modules.lazy.LazyModuleMixin
torch.nn.modules.lazy.LazyModuleMixin.has_uninitialized_params()
torch.nn.modules.lazy.LazyModuleMixin.initialize_parameters()
torch.nn.modules.module.register_module_backward_hook()
torch.nn.modules.module.register_module_forward_hook()
torch.nn.modules.module.register_module_forward_pre_hook()
torch.nn.parallel.DistributedDataParallel
torch.nn.parallel.DistributedDataParallel.join()
torch.nn.parallel.DistributedDataParallel.no_sync()
torch.nn.parallel.DistributedDataParallel.register_comm_hook()
torch.nn.parameter.Parameter
torch.nn.parameter.UninitializedParameter
torch.nn.parameter.UninitializedParameter.materialize()
torch.nn.utils.clip_grad_norm_()
torch.nn.utils.clip_grad_value_()
torch.nn.utils.parameters_to_vector()
torch.nn.utils.prune.BasePruningMethod
torch.nn.utils.prune.BasePruningMethod.apply()
torch.nn.utils.prune.BasePruningMethod.apply_mask()
torch.nn.utils.prune.BasePruningMethod.compute_mask()
torch.nn.utils.prune.BasePruningMethod.prune()
torch.nn.utils.prune.BasePruningMethod.remove()
torch.nn.utils.prune.CustomFromMask
torch.nn.utils.prune.CustomFromMask.apply()
torch.nn.utils.prune.CustomFromMask.apply_mask()
torch.nn.utils.prune.CustomFromMask.prune()
torch.nn.utils.prune.CustomFromMask.remove()
torch.nn.utils.prune.Identity
torch.nn.utils.prune.Identity.apply()
torch.nn.utils.prune.Identity.apply_mask()
torch.nn.utils.prune.Identity.prune()
torch.nn.utils.prune.Identity.remove()
torch.nn.utils.prune.L1Unstructured
torch.nn.utils.prune.L1Unstructured.apply()
torch.nn.utils.prune.L1Unstructured.apply_mask()
torch.nn.utils.prune.L1Unstructured.prune()
torch.nn.utils.prune.L1Unstructured.remove()
torch.nn.utils.prune.LnStructured
torch.nn.utils.prune.LnStructured.apply()
torch.nn.utils.prune.LnStructured.apply_mask()
torch.nn.utils.prune.LnStructured.compute_mask()
torch.nn.utils.prune.LnStructured.prune()
torch.nn.utils.prune.LnStructured.remove()
torch.nn.utils.prune.PruningContainer
torch.nn.utils.prune.PruningContainer.add_pruning_method()
torch.nn.utils.prune.PruningContainer.apply()
torch.nn.utils.prune.PruningContainer.apply_mask()
torch.nn.utils.prune.PruningContainer.compute_mask()
torch.nn.utils.prune.PruningContainer.prune()
torch.nn.utils.prune.PruningContainer.remove()
torch.nn.utils.prune.RandomStructured
torch.nn.utils.prune.RandomStructured.apply()
torch.nn.utils.prune.RandomStructured.apply_mask()
torch.nn.utils.prune.RandomStructured.compute_mask()
torch.nn.utils.prune.RandomStructured.prune()
torch.nn.utils.prune.RandomStructured.remove()
torch.nn.utils.prune.RandomUnstructured
torch.nn.utils.prune.RandomUnstructured.apply()
torch.nn.utils.prune.RandomUnstructured.apply_mask()
torch.nn.utils.prune.RandomUnstructured.prune()
torch.nn.utils.prune.RandomUnstructured.remove()
torch.nn.utils.prune.custom_from_mask()
torch.nn.utils.prune.global_unstructured()
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.PackedSequence
torch.nn.utils.rnn.PackedSequence.batch_sizes()
torch.nn.utils.rnn.PackedSequence.count()
torch.nn.utils.rnn.PackedSequence.data()
torch.nn.utils.rnn.PackedSequence.index()
torch.nn.utils.rnn.PackedSequence.is_cuda()
torch.nn.utils.rnn.PackedSequence.is_pinned()
torch.nn.utils.rnn.PackedSequence.sorted_indices()
torch.nn.utils.rnn.PackedSequence.to()
torch.nn.utils.rnn.PackedSequence.unsorted_indices()
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.spectral_norm()
torch.nn.utils.vector_to_parameters()
torch.nn.utils.weight_norm()
torch.nn.init
torch.nn.init
torch.nn.init.calculate_gain()
torch.nn.init.constant_()
torch.nn.init.dirac_()
torch.nn.init.eye_()
torch.nn.init.kaiming_normal_()
torch.nn.init.kaiming_uniform_()
torch.nn.init.normal_()
torch.nn.init.ones_()
torch.nn.init.orthogonal_()
torch.nn.init.sparse_()
torch.nn.init.uniform_()
torch.nn.init.xavier_normal_()
torch.nn.init.xavier_uniform_()
torch.nn.init.zeros_()
Quantization
torch.nn.intrinsic.ConvBn1d
torch.nn.intrinsic.ConvBn2d
torch.nn.intrinsic.ConvBnReLU1d
torch.nn.intrinsic.ConvBnReLU2d
torch.nn.intrinsic.ConvReLU1d
torch.nn.intrinsic.ConvReLU2d
torch.nn.intrinsic.qat.ConvBn2d
torch.nn.intrinsic.qat.ConvBnReLU2d
torch.nn.intrinsic.qat.ConvReLU2d
torch.nn.intrinsic.qat.LinearReLU
torch.nn.intrinsic.quantized.ConvReLU2d
torch.nn.intrinsic.quantized.ConvReLU3d
torch.nn.intrinsic.quantized.LinearReLU
torch.nn.qat.Conv2d
torch.nn.qat.Conv2d.from_float()
torch.nn.qat.Linear
torch.nn.qat.Linear.from_float()
torch.nn.quantized.BatchNorm2d
torch.nn.quantized.BatchNorm3d
torch.nn.quantized.Conv1d
torch.nn.quantized.Conv1d.from_float()
torch.nn.quantized.Conv2d
torch.nn.quantized.Conv2d.from_float()
torch.nn.quantized.Conv3d
torch.nn.quantized.Conv3d.from_float()
torch.nn.quantized.DeQuantize
torch.nn.quantized.ELU
torch.nn.quantized.Embedding
torch.nn.quantized.Embedding.from_float()
torch.nn.quantized.EmbeddingBag
torch.nn.quantized.EmbeddingBag.from_float()
torch.nn.quantized.FloatFunctional
torch.nn.quantized.GroupNorm
torch.nn.quantized.Hardswish
torch.nn.quantized.InstanceNorm1d
torch.nn.quantized.InstanceNorm2d
torch.nn.quantized.InstanceNorm3d
torch.nn.quantized.LayerNorm
torch.nn.quantized.Linear
torch.nn.quantized.Linear.from_float()
torch.nn.quantized.QFunctional
torch.nn.quantized.Quantize
torch.nn.quantized.ReLU6
torch.nn.quantized.functional.adaptive_avg_pool2d()
torch.nn.quantized.functional.avg_pool2d()
torch.nn.quantized.functional.conv1d()
torch.nn.quantized.functional.conv2d()
torch.nn.quantized.functional.conv3d()
torch.nn.quantized.functional.hardswish()
torch.nn.quantized.functional.interpolate()
torch.nn.quantized.functional.linear()
torch.nn.quantized.functional.max_pool2d()
torch.nn.quantized.functional.upsample()
torch.nn.quantized.functional.upsample_bilinear()
torch.nn.quantized.functional.upsample_nearest()
torch.nn.quantized.dynamic
torch.nn.quantized.dynamic
torch.nn.quantized.dynamic.GRUCell
torch.nn.quantized.dynamic.LSTM
torch.nn.quantized.dynamic.LSTMCell
torch.nn.quantized.dynamic.Linear
torch.nn.quantized.dynamic.Linear.from_float()
torch.nn.quantized.dynamic.RNNCell
torch.onnx
torch.onnx
torch.onnx.export()
torch.onnx.export_to_pretty_string()
torch.onnx.is_in_onnx_export()
torch.onnx.operators.shape_as_tensor()
torch.onnx.register_custom_op_symbolic()
torch.onnx.select_model_mode_for_export()
torch.optim
torch.optim
torch.optim.ASGD
torch.optim.ASGD.step()
torch.optim.Adadelta
torch.optim.Adadelta.step()
torch.optim.Adagrad
torch.optim.Adagrad.step()
torch.optim.Adam
torch.optim.Adam.step()
torch.optim.AdamW
torch.optim.AdamW.step()
torch.optim.Adamax
torch.optim.Adamax.step()
torch.optim.LBFGS
torch.optim.LBFGS.step()
torch.optim.Optimizer
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.optim.RMSprop
torch.optim.RMSprop.step()
torch.optim.Rprop
torch.optim.Rprop.step()
torch.optim.SGD
torch.optim.SGD.step()
torch.optim.SparseAdam
torch.optim.SparseAdam.step()
torch.optim.lr_scheduler.CosineAnnealingLR
torch.optim.lr_scheduler.CosineAnnealingWarmRestarts
torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.step()
torch.optim.lr_scheduler.CyclicLR
torch.optim.lr_scheduler.CyclicLR.get_lr()
torch.optim.lr_scheduler.ExponentialLR
torch.optim.lr_scheduler.LambdaLR
torch.optim.lr_scheduler.LambdaLR.load_state_dict()
torch.optim.lr_scheduler.LambdaLR.state_dict()
torch.optim.lr_scheduler.MultiStepLR
torch.optim.lr_scheduler.MultiplicativeLR
torch.optim.lr_scheduler.MultiplicativeLR.load_state_dict()
torch.optim.lr_scheduler.MultiplicativeLR.state_dict()
torch.optim.lr_scheduler.OneCycleLR
torch.optim.lr_scheduler.ReduceLROnPlateau
torch.optim.lr_scheduler.StepLR
torch.overrides
torch.overrides
torch.overrides.get_ignored_functions()
torch.overrides.get_overridable_functions()
torch.overrides.get_testing_overrides()
torch.overrides.handle_torch_function()
torch.overrides.has_torch_function()
torch.overrides.is_tensor_like()
torch.overrides.is_tensor_method_or_property()
torch.overrides.wrap_torch_function()
torch.quantization
torch.quantization
torch.quantization.DeQuantStub
torch.quantization.FakeQuantize
torch.quantization.HistogramObserver
torch.quantization.MinMaxObserver
torch.quantization.MovingAverageMinMaxObserver
torch.quantization.MovingAveragePerChannelMinMaxObserver
torch.quantization.NoopObserver
torch.quantization.ObserverBase
torch.quantization.ObserverBase.with_args()
torch.quantization.PerChannelMinMaxObserver
torch.quantization.QConfig
torch.quantization.QConfigDynamic
torch.quantization.QuantStub
torch.quantization.QuantWrapper
torch.quantization.RecordingObserver
torch.quantization.add_observer_()
torch.quantization.add_quant_dequant()
torch.quantization.convert()
torch.quantization.default_eval_fn()
torch.quantization.fuse_modules()
torch.quantization.get_observer_dict()
torch.quantization.prepare()
torch.quantization.prepare_qat()
torch.quantization.propagate_qconfig_()
torch.quantization.quantize()
torch.quantization.quantize_dynamic()
torch.quantization.quantize_qat()
torch.quantization.swap_module()
torch.random
torch.random
torch.random.fork_rng()
torch.random.get_rng_state()
torch.random.initial_seed()
torch.random.manual_seed()
torch.random.seed()
torch.random.set_rng_state()
torch.Tensor
torch.Tensor
torch.Tensor.T
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.all()
torch.Tensor.allclose()
torch.Tensor.amax()
torch.Tensor.amin()
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.arctan_()
torch.Tensor.arctanh()
torch.Tensor.arctanh_()
torch.Tensor.argmax()
torch.Tensor.argmin()
torch.Tensor.argsort()
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.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_not()
torch.Tensor.bitwise_not_()
torch.Tensor.bitwise_or()
torch.Tensor.bitwise_or_()
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.ceil()
torch.Tensor.ceil_()
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.conj()
torch.Tensor.contiguous()
torch.Tensor.copy_()
torch.Tensor.copysign()
torch.Tensor.copysign_()
torch.Tensor.cos()
torch.Tensor.cos_()
torch.Tensor.cosh()
torch.Tensor.cosh_()
torch.Tensor.count_nonzero()
torch.Tensor.cpu()
torch.Tensor.cross()
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.dequantize()
torch.Tensor.det()
torch.Tensor.device
torch.Tensor.diag()
torch.Tensor.diag_embed()
torch.Tensor.diagflat()
torch.Tensor.diagonal()
torch.Tensor.diff()
torch.Tensor.digamma()
torch.Tensor.digamma_()
torch.Tensor.dim()
torch.Tensor.dist()
torch.Tensor.div()
torch.Tensor.div_()
torch.Tensor.divide()
torch.Tensor.divide_()
torch.Tensor.dot()
torch.Tensor.double()
torch.Tensor.eig()
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.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.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.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_select()
torch.Tensor.inner()
torch.Tensor.int()
torch.Tensor.int_repr()
torch.Tensor.inverse()
torch.Tensor.is_complex()
torch.Tensor.is_contiguous()
torch.Tensor.is_cuda
torch.Tensor.is_floating_point()
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.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.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.lstsq()
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.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.nanmedian()
torch.Tensor.nanquantile()
torch.Tensor.nansum()
torch.Tensor.narrow()
torch.Tensor.narrow_copy()
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.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.remainder()
torch.Tensor.remainder_()
torch.Tensor.renorm()
torch.Tensor.renorm_()
torch.Tensor.repeat()
torch.Tensor.repeat_interleave()
torch.Tensor.requires_grad_()
torch.Tensor.reshape()
torch.Tensor.reshape_as()
torch.Tensor.resize_()
torch.Tensor.resize_as_()
torch.Tensor.roll()
torch.Tensor.rot90()
torch.Tensor.round()
torch.Tensor.round_()
torch.Tensor.rsqrt()
torch.Tensor.rsqrt_()
torch.Tensor.scatter()
torch.Tensor.scatter_()
torch.Tensor.scatter_add()
torch.Tensor.scatter_add_()
torch.Tensor.select()
torch.Tensor.set_()
torch.Tensor.sgn()
torch.Tensor.sgn_()
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.slogdet()
torch.Tensor.solve()
torch.Tensor.sort()
torch.Tensor.split()
torch.Tensor.sqrt()
torch.Tensor.sqrt_()
torch.Tensor.square()
torch.Tensor.square_()
torch.Tensor.squeeze()
torch.Tensor.squeeze_()
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.symeig()
torch.Tensor.t()
torch.Tensor.t_()
torch.Tensor.take()
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_mkldnn()
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.unfold()
torch.Tensor.uniform_()
torch.Tensor.unique()
torch.Tensor.unique_consecutive()
torch.Tensor.unsqueeze()
torch.Tensor.unsqueeze_()
torch.Tensor.var()
torch.Tensor.vdot()
torch.Tensor.view()
torch.Tensor.view_as()
torch.Tensor.where()
torch.Tensor.xlogy()
torch.Tensor.xlogy_()
torch.Tensor.zero_()
Named Tensors
torch.Tensor.align_as()
torch.Tensor.align_to()
torch.Tensor.names
torch.Tensor.refine_names()
torch.Tensor.rename()
torch.Tensor.rename_()
torch.Tensor.unflatten()
Tensor Attributes
torch.torch.device
torch.torch.dtype
torch.torch.layout
torch.torch.memory_format
Type Info
torch.torch.finfo
torch.torch.iinfo
torch.utils.benchmark
torch.utils.benchmark
torch.utils.benchmark.CallgrindStats
torch.utils.benchmark.CallgrindStats.as_standardized()
torch.utils.benchmark.CallgrindStats.counts()
torch.utils.benchmark.CallgrindStats.delta()
torch.utils.benchmark.CallgrindStats.stats()
torch.utils.benchmark.FunctionCounts
torch.utils.benchmark.FunctionCounts.denoise()
torch.utils.benchmark.FunctionCounts.filter()
torch.utils.benchmark.FunctionCounts.transform()
torch.utils.benchmark.Measurement
torch.utils.benchmark.Measurement.merge()
torch.utils.benchmark.Measurement.significant_figures()
torch.utils.benchmark.Timer
torch.utils.benchmark.Timer.blocked_autorange()
torch.utils.benchmark.Timer.collect_callgrind()
torch.utils.benchmark.Timer.timeit()
torch.utils.bottleneck
torch.utils.bottleneck
torch.utils.checkpoint
torch.utils.checkpoint
torch.utils.checkpoint.checkpoint()
torch.utils.checkpoint.checkpoint_sequential()
torch.utils.cpp_extension
torch.utils.cpp_extension
torch.utils.cpp_extension.BuildExtension()
torch.utils.cpp_extension.CUDAExtension()
torch.utils.cpp_extension.CppExtension()
torch.utils.cpp_extension.check_compiler_abi_compatibility()
torch.utils.cpp_extension.include_paths()
torch.utils.cpp_extension.is_ninja_available()
torch.utils.cpp_extension.load()
torch.utils.cpp_extension.load_inline()
torch.utils.cpp_extension.verify_ninja_availability()
torch.utils.data
torch.utils.data
torch.utils.data.BatchSampler
torch.utils.data.BufferedShuffleDataset
torch.utils.data.ChainDataset
torch.utils.data.ConcatDataset
torch.utils.data.DataLoader
torch.utils.data.Dataset
torch.utils.data.IterableDataset
torch.utils.data.RandomSampler
torch.utils.data.Sampler
torch.utils.data.SequentialSampler
torch.utils.data.Subset
torch.utils.data.SubsetRandomSampler
torch.utils.data.TensorDataset
torch.utils.data.WeightedRandomSampler
torch.utils.data.distributed.DistributedSampler
torch.utils.data.get_worker_info()
torch.utils.data.random_split()
torch.utils.dlpack
torch.utils.dlpack
torch.utils.dlpack.from_dlpack()
torch.utils.dlpack.to_dlpack()
torch.utils.mobile_optimizer
torch.utils.mobile_optimizer
torch.utils.mobile_optimizer.optimize_for_mobile()
torch.utils.model_zoo
torch.utils.model_zoo
torch.utils.model_zoo.load_url()
torch.utils.tensorboard
torch.utils.tensorboard
torch.utils.tensorboard.writer.SummaryWriter
torch.utils.tensorboard.writer.SummaryWriter.__init__()
torch.utils.tensorboard.writer.SummaryWriter.add_audio()
torch.utils.tensorboard.writer.SummaryWriter.add_custom_scalars()
torch.utils.tensorboard.writer.SummaryWriter.add_embedding()
torch.utils.tensorboard.writer.SummaryWriter.add_figure()
torch.utils.tensorboard.writer.SummaryWriter.add_graph()
torch.utils.tensorboard.writer.SummaryWriter.add_histogram()
torch.utils.tensorboard.writer.SummaryWriter.add_hparams()
torch.utils.tensorboard.writer.SummaryWriter.add_image()
torch.utils.tensorboard.writer.SummaryWriter.add_images()
torch.utils.tensorboard.writer.SummaryWriter.add_mesh()
torch.utils.tensorboard.writer.SummaryWriter.add_pr_curve()
torch.utils.tensorboard.writer.SummaryWriter.add_scalar()
torch.utils.tensorboard.writer.SummaryWriter.add_scalars()
torch.utils.tensorboard.writer.SummaryWriter.add_text()
torch.utils.tensorboard.writer.SummaryWriter.add_video()
torch.utils.tensorboard.writer.SummaryWriter.close()
torch.utils.tensorboard.writer.SummaryWriter.flush()
Copyright ©2024 TypeError Powered By AnyPost, page cost 79ms.
Privacy Policy