中间表示法

PyTorch 2.0 提供了两种中间表示（IR）供后端使用：Core Aten IR 和 Prims IR。

核心Aten IR

Core Aten 操作是指可以在其他操作中组合使用的 Aten 操作的核心子集。Core Aten IR 是完全功能性且不包含 inplace 或 _out 变体的操作集合。与 Prims IR 不同，Core Aten 操作重用了“native_functions.yaml”中的现有 Aten 操作，并不会进一步将操作分解为显式的类型提升和广播操作。此操作集旨在作为功能 IR 以与后端进行接口。

警告

此运算符集合仍在积极开发中，未来将会添加更多的操作。

运算符	模式
`aten._adaptive_avg_pool2d`	_adaptive_avg_pool2d(Tensor self, SymInt[2] output_size) -> Tensor
`aten._adaptive_avg_pool2d_backward`	_adaptive_avg_pool2d_backward(Tensor grad_output, Tensor self) -> Tensor
`aten._adaptive_avg_pool3d`	_adaptive_avg_pool3d(Tensor self, SymInt[3] output_size) -> Tensor
`aten._cdist_forward`	_cdist_forward(Tensor x1, Tensor x2, float p, int? compute_mode) 返回 Tensor
`aten._embedding_bag`	_embedding_bag(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq=False, int mode=0, bool sparse=False, Tensor per_sample_weights=None, bool include_last_offset=False, int padding_idx=-1) -> (Tensor, Tensor, Tensor, Tensor)
`aten._local_scalar_dense`	_local_scalar_dense(Tensor self) -> Scalar
`aten._log_softmax`	_log_softmax(Tensor self, int dim, bool half_to_float) -> Tensor
`aten._native_batch_norm_legit`	_native_batch_norm_legit(Tensor 输入, Tensor? 权重, Tensor? 偏置, Tensor(a!) 运行均值, Tensor(b!) 运行方差, bool 训练状态, float 动量, float eps) -> (Tensor, Tensor, Tensor)
`aten._native_batch_norm_legit.no_stats`	_native_batch_norm_legit.no_stats(Tensor 输入, Tensor? 权重, Tensor? 偏置, bool 训练, float 动量, float eps) -> (Tensor, Tensor, Tensor)
`aten._native_batch_norm_legit_no_training`	_native_batch_norm_legit_no_training(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, float momentum, float eps) 返回 (Tensor, Tensor, Tensor)
`aten._pdist_forward`	_pdist_forward(Tensor self, float p=2) -> Tensor
`aten._softmax`	_softmax(Tensor self, int dim, bool half_to_float) -> Tensor
`aten._to_copy`	_to_copy(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, bool non_blocking=False, MemoryFormat? memory_format=None) -> Tensor
`aten.abs`	abs(Tensor self) -> Tensor
`aten.acos`	acos(Tensor self) → Tensor
`aten.acosh`	acosh(Tensor self) -> Tensor
`aten.adaptive_avg_pool1d`	adaptive_avg_pool1d(Tensor self, int输出大小) -> Tensor
`aten.add.Scalar`	Tensor add.Scalar(Tensor self, Scalar other, Scalar alpha=1)
`aten.add.Tensor`	Tensor add.Tensor(Tensor self, Tensor other, *, Scalar alpha=1)
`aten.addmm`	addmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor
`aten.alias`	alias(Tensor(a) self) -> Tensor(a)
`aten.amax`	amax(Tensor self, dims=[1], keepdim=False) -> Tensor
`aten.amin`	amin(Tensor self, int[1] dim=[], bool keepdim=False) -> Tensor
`aten.any`	any(Tensor self) -> Tensor
`aten.any.dim`	any.dim(Tensor self, int dim, bool keepdim=False) -> Tensor
`aten.any.dims`	any.dims(Tensor self, int[]? dim=None, bool keepdim=False) -> Tensor
`aten.arange(start, step)`	arange.start_step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
`aten.argmax`	argmax(Tensor self, dim: int = None, keepdim: bool = False) -> Tensor
`aten.argmin`	argmin(Tensor self, dim: int? = None, keepdim: bool = False) -> Tensor
`aten.as_strided`	as_strided(Tensor(a) self, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor(a)
`aten.asin`	asin(self Tensor) -> Tensor
`aten.asinh`	asinh(Tensor self) -> Tensor
`aten.atan`	atan(Tensor self) -> Tensor
`aten.atan2`	atan2(Tensor 自变量, Tensor 另一变量) -> Tensor
`aten.atan2.out`	atan2.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
`aten.atanh`	atanh(Tensor self) -> Tensor
`aten.avg_pool1d`	avg_pool1d(Tensor self, int kernel_size, int stride=[], int padding=0, bool ceil_mode=False, bool count_include_pad=True) -> Tensor
`aten.avg_pool2d`	avg_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None) -> Tensor
`aten.avg_pool2d_backward`	avg_pool2d_backward(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, bool ceil_mode, bool count_include_pad, int? divisor_override) -> Tensor
`aten.avg_pool3d`	avg_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None) -> Tensor
`aten.bitwise_and.Scalar`	bitwise_and.Scalar(Tensor self, Scalar other) -> Tensor
`aten.bitwise_and.Tensor`	bitwise_and.Tensor(Tensor self, Tensor other) -> Tensor
`aten.bitwise_not`	bitwise_not(Tensor self) -> Tensor
`aten.bitwise_or.Scalar`	bitwise_or.Scalar(Tensor self, Scalar other) -> Tensor
`aten.bitwise_or.Tensor`	bitwise_or.Tensor(Tensor self, Tensor other) -> Tensor
`aten.bitwise_xor.Scalar`	bitwise_xor.Scalar(Tensor self, Scalar other) -> Tensor
`aten.bitwise_xor.Tensor`	Tensor bitwise_xor(Tensor self, Tensor other) -> Tensor
`aten.bmm`	bmm(Tensor self, Tensor mat2) -> Tensor
`aten.cat`	cat(Tensor[] tensors, int dim=0) -> Tensor
`aten.ceil`	ceil(Tensor self) -> Tensor
`aten.clamp`	clamp(Tensor self, Scalar? min=None, Scalar? max=None) -> Tensor
`aten.clamp.Tensor`	clamp.Tensor(Tensor self, Tensor? min=None, Tensor? max=None) -> Tensor
`aten.clone`	clone(Tensor self, *, memory_format=None) -> Tensor
`aten.col2im`	col2im(Tensor self, SymInt[2] output_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor
`aten.constant_pad_nd`	constant_pad_nd(Tensor self, SymInt[] pad, Scalar value=0) -> Tensor
`aten.convolution`	convolution(Tensor 输入, Tensor 权重, Tensor? 偏置, SymInt[] 步幅, SymInt[] 填充, SymInt[] 膨胀, bool 是否转置, SymInt[] 输出填充, SymInt 组数) -> Tensor
`aten.convolution_backward`	convolution_backward(Tensor grad_output, Tensor input, Tensor weight, SymInt[]? bias_sizes, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
`aten.copy`	copy(Tensor self, Tensor src, bool non_blocking=False) -> Tensor
`aten.cos`	cos(Tensor self) → Tensor
`aten.cosh`	cosh(Tensor self) → Tensor
`aten.cumsum`	cumsum(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor
`aten.diagonal`	diagonal(Tensor(a) self, int offset=0, int dim1=0, int dim2=1) -> Tensor(a)
`aten.div.Scalar`	div.Scalar(Tensor self, Scalar other) → Tensor
`aten.div.Scalar_mode`	Sclar_mode(Tensor self, Scalar other, *, rounding_mode: str?) -> Tensor
`aten.div.Tensor`	Tensor div.Tensor(Tensor self, Tensor other) → Tensor
`aten.div.Tensor_mode` 保持不变，因为这句话已经是代码形式，无需修改。如果需要解释其含义或改写为自然语言描述，请提供更多信息。原文已很简洁，直接返回： `aten.div.Tensor_mode`	Tensor_mode(Tensor self, Tensor other, *, rounding_mode: str = None) -> Tensor
`aten.embedding`	embedding(Tensor weight, Tensor indices, SymInt padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False) -> Tensor
`aten.embedding_dense_backward`	embedding_dense_backward(Tensor grad_output, Tensor indices, SymInt num_weights, SymInt padding_idx, bool scale_grad_by_freq) -> Tensor
`aten.empty.memory_format`	empty.memory_format(SymInt[] size, *, dtype=ScalarType?, layout=Layout?, device=Device?, pin_memory=bool?, memory_format=MemoryFormat?) -> Tensor
`aten.empty_strided`	empty_strided(SymInt[] size, SymInt[] stride, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
`aten.eq.Scalar`	eq.Scalar(Tensor self, Scalar other) -> Tensor
`aten.eq.Tensor`	eq.Tensor(Tensor self, Tensor other) -> Tensor
`aten.erf`	erf(Tensor self) -> Tensor
`aten.exp`	exp(Tensor self) → Tensor
`aten.expand`	expand(Tensor(a) self, SymInt[] size, *, bool implicit=False) -> Tensor(a)
`aten.expm1`	expm1(Tensor self) → Tensor
`aten.fill.Scalar`	fill.Scalar(Tensor self, Scalar value) -> Tensor
`aten.flip`	flip(Tensor self, int[] dims) -> Tensor
`aten.floor`	floor(Tensor self) → Tensor
`aten.fmod.Scalar`	fmod.Scalar(Tensor self, Scalar other) -> Tensor
`aten.fmod.Tensor`	fmod.Tensor(Tensor self, Tensor other) → Tensor
`aten.full`	full(SymInt[] size, Scalar fill_value, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
`aten.gather`	gather(Tensor self, int dim, Tensor index, *, bool sparse_grad=False) -> Tensor
`aten.ge.Scalar`	ge.Scalar(Tensor self, Scalar other) -> Tensor
`torch.Tensor`	ge.Tensor(Tensor self, Tensor other) -> Tensor
`aten.gelu`	gelu(Tensor self, *, approximate='none' 的类型为 str) -> Tensor
`aten.grid_sampler_2d`	grid_sampler_2d(Tensor 输入, Tensor 网格, int 插值模式, int 填充模式, bool 对齐角落) -> Tensor
`aten.gt.Scalar`	gt.Scalar(Tensor self, Scalar other) -> Tensor
`aten.gt.Tensor`	torch.Tensor(self, other) -> Tensor
`aten.hardtanh`	hardtanh(Tensor self, Scalar min_val=-1, Scalar max_val=1) -> Tensor
`aten.index.Tensor`	index.Tensor(Tensor self, Tensor?[] indices) -> Tensor
`aten.index_put`	index_put(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False) -> Tensor
`aten.index_select`	index_select(Tensor self, int dim, Tensor index) -> Tensor
`aten.isinf`	isinf(Tensor self) → Tensor
`aten.isnan`	isnan(Tensor self) -> Tensor
`aten.le.Scalar`	le.Scalar(Tensor self, Scalar other) -> Tensor
`aten.le.Tensor`	le.Tensor(Tensor self, Tensor other) -> Tensor
`aten.leaky_relu`	leaky_relu(Tensor self, Scalar negative_slope=0.01) -> Tensor
`aten.log`	log(Tensor self) → Tensor
`aten.log10`	log10(Tensor self) -> Tensor
`aten.log1p`	log1p(Tensor self) -> Tensor
`aten.log2`	log2(Tensor self) -> Tensor
`aten.logical_and`	logical_and(Tensor self, Tensor other) -> Tensor
`aten.logical_not`	logical_not(Tensor self) -> Tensor
`aten.logical_or`	logical_or(Tensor self, Tensor other) -> Tensor
`aten.logical_xor`	logical_xor(Tensor self, Tensor other) -> Tensor
`aten.lt.Scalar`	lt.Scalar(Tensor self, Scalar other) -> Tensor
`torch.Tensor`	lt.Tensor(Tensor self, Tensor other) -> Tensor
`aten.max.dim`	max.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices)
`aten.max_pool2d_with_indices`	max_pool2d_with_indices(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> (Tensor, Tensor)
`aten.max_pool2d_with_indices_backward`	max_pool2d_with_indices_backward(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, bool ceil_mode, Tensor indices) -> Tensor
`aten.max_pool3d_with_indices`	max_pool3d_with_indices(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> (Tensor, Tensor)
`aten.maximum`	maximum(Tensor self, Tensor other) -> Tensor
`aten.mean`	mean(Tensor self, *, dtype=ScalarType?) -> Tensor
`aten.mean.dim`	mean.dim(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
`aten.min_dim`	min.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices)
`aten.minimum`	minimum(Tensor self, Tensor other) -> Tensor
`aten.mm`	mm(Tensor self, Tensor mat2) -> Tensor
`aten.mul.Scalar`	Tensor mul.Scalar(Tensor self, Scalar other)
`aten.mul.Tensor`	mul.Tensor(Tensor self, Tensor other) → Tensor
`aten.native_dropout`	native_dropout(Tensor input, float p, bool? train) -> (Tensor, Tensor)
`aten.native_group_norm`	native_group_norm(Tensor 输入, Tensor? 权重, Tensor? 偏置, SymInt N, SymInt C, SymInt HxW, int group, float eps) -> (Tensor, Tensor, Tensor)
`aten.native_group_norm_backward`	native_group_norm_backward(Tensor grad_out, Tensor input, Tensor mean, Tensor rstd, Tensor? weight, SymInt N, SymInt C, SymInt HxW, int group, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
`aten.native_layer_norm`	native_layer_norm(Tensor 输入, SymInt[] 归一化形状, Tensor? 权重, Tensor? 偏置, float eps) -> (Tensor, Tensor, Tensor)
`aten.native_layer_norm_backward`	native_layer_norm_backward(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
`aten.ne.Scalar`	ne.Scalar(Tensor self, Scalar other) -> Tensor
`aten.ne.Tensor`	torch.Tensor(self, other) -> torch.Tensor
`aten.neg`	neg(Tensor self) -> Tensor
`aten.nonzero`	nonzero(Tensor self) -> Tensor
`aten.permute`	permute(Tensor(a) self, int[] dims) -> Tensor(a)
`aten.pow.Scalar`	pow.Scalar(Scalar self, Tensor 指数) -> Tensor
`aten.pow.Tensor_Scalar`	Tensor pow.Tensor_Scalar(Tensor self, Scalar exponent)
`aten.pow.Tensor_Tensor`	Tensor pow.Tensor_Tensor(Tensor self, Tensor exponent)
`aten.prod`	prod(Tensor self, *, dtype=ScalarType?) -> Tensor
`aten.prod.dim_int`	prod.dim_int(Tensor self, int dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor
`aten.rand`	rand(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
`aten.randn`	randn(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
`aten.randperm`	randperm(SymInt n, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
`aten.reciprocal`	reciprocal(Tensor self) -> Tensor
`aten.reflection_pad1d`	reflection_pad1d(Tensor self, SymInt[2] padding) -> Tensor
`aten.reflection_pad2d`	reflection_pad2d(Tensor self, SymInt[4] padding) -> Tensor
`aten.reflection_pad3d`	reflection_pad3d(Tensor self, SymInt[6] padding) -> Tensor
`aten.relu`	relu(Tensor self) -> Tensor
`aten.remainder.Scalar`	Tensor remainder.Scalar(Tensor self, Scalar other)
`aten.remainder.Tensor`	Tensor.remainder(Tensor self, Tensor other) -> Tensor
`aten.repeat`	repeat(Tensor self, SymInt[] repeats) -> Tensor
`aten.replication_pad2d`	replication_pad2d(Tensor self, SymInt[4] padding) -> Tensor
`aten.replication_pad3d`	replication_pad3d(Tensor self, SymInt[6] padding) -> Tensor
`aten.resize_`	resize_(Tensor(a!) self, SymInt[] size, *, MemoryFormat? memory_format=None) -> Tensor(a!)
`aten.round`	round(Tensor self) -> Tensor
`aten.rsqrt`	rsqrt(Tensor self) -> Tensor
`aten.scalar_tensor`	scalar_tensor(Scalar s, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
`aten.scatter.src`	scatter.src(Tensor self, int dim, Tensor index, Tensor src) → Tensor
`aten.scatter_value`	scatter.value(Tensor self, int dim, Tensor index, Scalar value) → Tensor
`aten.scatter_add`	scatter_add(Tensor self, int dim, Tensor index, Tensor src) -> Tensor
`aten.scatter_reduce.two`	scatter_reduce.two(Tensor self, int dim, Tensor index, Tensor src, str reduce, *, bool include_self=True) -> Tensor
`aten.select.int`	select.int(Tensor(a) self, int dim, SymInt index) -> Tensor(a)
`aten.select_scatter`	select_scatter(Tensor self, Tensor src, int dim, SymInt index) -> Tensor
`aten.sigmoid`	sigmoid(Tensor self) -> Tensor
`aten.sign`	sign(Tensor self) -> Tensor
`aten.sin`	sin(Tensor self) → Tensor
`aten.sinh`	sinh(Tensor self) -> Tensor
`aten.slice.Tensor`	slice.Tensor(Tensor(a) self, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1) -> Tensor(a)
`aten.slice_scatter`	slice_scatter(Tensor self, Tensor src, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1) -> Tensor
`aten.sort`	sort(Tensor self, int dim=-1, bool descending=False) -> (Tensor values, Tensor indices)
`aten.split_with_sizes`	split_with_sizes(Tensor(a -> *) self, SymInt[] split_sizes, int dim=0) -> Tensor(a)[]
`aten.sqrt`	sqrt(Tensor self) -> Tensor
`aten.squeeze.dim`	squeeze.dim(Tensor(a) self, int dim) → Tensor(a)
`aten.squeeze.dims`	squeeze.dims(Tensor(a) self, int[] dim) -> Tensor(a)
`aten.sub.Scalar`	sub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor
`aten.sub.Tensor`	Tensor sub.Tensor(Tensor self, Tensor other, *, Scalar alpha=1)
`aten.sum.dim_IntList`	sum.dim_IntList(Tensor self, int[1]？dim, bool keepdim=False, *, ScalarType？dtype=None) -> Tensor
`aten.sym_numel`	sym_numel(Tensor self) -> SymInt
`aten.sym_size.int`	sym_size.int(Tensor self, int dim) -> SymInt
`aten.sym_storage_offset`	sym_storage_offset(Tensor self) -> SymInt
`aten.sym_stride.int`	sym_stride.int(Tensor self, int dim) -> SymInt
`aten.tan`	tan(Tensor self) -> Tensor
`aten.tanh`	tanh(Tensor 自身) -> Tensor
`aten.topk`	topk(Tensor self, SymInt k, int dim=-1, bool largest=True, bool sorted=True) -> (Tensor values, Tensor indices)
`aten.trunc`	trunc(Tensor self) -> Tensor
`aten.unsqueeze`	unsqueeze(Tensor(a) self, int dim) -> Tensor(a)
`aten.upsample_bilinear2d.vec`	upsample_bilinear2d.vec(Tensor 输入, SymInt[]? 输出大小, bool align_corners, float[]? 缩放因子) -> Tensor
`aten.upsample_nearest2d.vec`	upsample_nearest2d(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor
`aten.var.correction`	var.correction(Tensor self, int[1] dim=None, *, Scalar correction=None, bool keepdim=False) -> Tensor
`aten.var.dim`	var.dim(Tensor self, int? dim, bool unbiased=True, bool keepdim=False) -> Tensor
`aten.view`	view(Tensor(a) self, SymInt[] size) -> Tensor(a)
`aten.where.self`	where(Tensor condition, Tensor self, Tensor other) -> Tensor

普里斯红外线

Prims IR 是一组基本的操作符，可以用来组合其他操作符。它的级别低于核心 aten IR，并且它进一步将操作符分解为显式的类型提升和广播操作符：prims.convert_element_type 和 prims.broadcast_in_dim。这个操作集设计用于与编译器后端进行接口。

警告

此运算符集合仍在积极开发中，未来将会添加更多的操作。

运算符	模式
`prims.abs`	Tensor(self) → Tensor
`prims.acos`	Tensor(self) → Tensor
`prims.acosh`	Tensor(self) → Tensor
`prims.asin`	Tensor(self) → Tensor
`prims.asinh`	Tensor(self) → Tensor
`prims.atan`	Tensor(self) → Tensor
`prims.atanh`	Tensor(self) → Tensor
`prims.cos`	Tensor(self) → Tensor
`prims.cosh`	Tensor(self) → Tensor
`prims.bessel_i0`	Tensor(self) → Tensor
`prims.bessel_i0e`	Tensor(self) → Tensor
`prims.bessel_i1`	Tensor(self) → Tensor
`prims.bessel_i1e`	Tensor(self) → Tensor
`prims.bessel_j0`	Tensor(self) → Tensor
`prims.bessel_j1`	Tensor(self) → Tensor
`prims.bitwise_not`	Tensor(self) → Tensor
`prims.cbrt`	Tensor(self) → Tensor
`prims.ceil`	Tensor(self) → Tensor
`prims.conj_physical`	Tensor(self) → Tensor
`prims.digamma`	Tensor(self) → Tensor
`prims.erf`	Tensor(self) → Tensor
`prims.erf_inv`	Tensor(self) → Tensor
`prims.erfc`	Tensor(self) → Tensor
`prims.erfcx`	Tensor(self) → Tensor
`prims.exp`	Tensor(self) → Tensor
`prims.expm1`	Tensor(self) → Tensor
`prims.exp2`	Tensor(self) → Tensor
`prims.fill`	(Tensor self, Scalar value) → Tensor
`prims.floor`	Tensor(self) → Tensor
`prims.imag`	Tensor(a) self -> Tensor(a)
`prims.isfinite`	Tensor(self) → Tensor
`prims.lgamma`	Tensor(self) → Tensor
`prims.log`	Tensor(self) → Tensor
`prims.log1p`	Tensor(self) → Tensor
`prims.log2`	Tensor(self) → Tensor
`prims.log10`	Tensor(self) → Tensor
`prims.ndtri`	Tensor(self) → Tensor
`prims.neg`	Tensor(self) → Tensor
`prims.real`	Tensor(a) self -> Tensor(a)
`prims.reciprocal`	Tensor(self) → Tensor
`prims.round`	Tensor(self) → Tensor
`prims.sign`	Tensor(self) → Tensor
`prims.signbit`	Tensor(self) → Tensor
`prims.sin`	Tensor(self) → Tensor
`prims.sinh`	Tensor(self) → Tensor
`prims.spherical_bessel_j0`	Tensor(self) → Tensor
`prims.sqrt`	Tensor(self) → Tensor
`prims.tan`	Tensor(self) → Tensor
`prims.tanh`	Tensor(self) → Tensor
`prims.trunc`	Tensor(self) → Tensor
`prims.add`	(Tensor self, Tensor other) → Tensor
`prims.atan2`	(Tensor self, Tensor other) → Tensor
`prims.bitwise_and`	(Tensor self, Tensor other) → Tensor
`prims.bitwise_or`	(Tensor self, Tensor other) → Tensor
`prims.bitwise_xor`	(Tensor self, Tensor other) → Tensor
`prims.div`	(Tensor self, Tensor other) → Tensor
`prims.eq`	(Tensor self, Tensor other) → Tensor
`prims.fmax`	(Tensor self, Tensor other) → Tensor
`prims.fmin`	(Tensor self, Tensor other) → Tensor
`prims.fmod`	(Tensor self, Tensor other) → Tensor
`prims.frexp`	(Tensor self) -> (Tensor 有效数字, Tensor 指数)
`prims.gcd`	(Tensor self, Tensor other) → Tensor
`prims.ge`	(Tensor self, Tensor other) → Tensor
`prims.gt`	(Tensor self, Tensor other) → Tensor
`prims.hypot`	(Tensor self, Tensor other) → Tensor
`prims.igamma`	(Tensor self, Tensor other) → Tensor
`prims.igammc`	(Tensor self, Tensor other) → Tensor
`prims.le`	(Tensor self, Tensor other) → Tensor
`prims.lt`	(Tensor self, Tensor other) → Tensor
`prims.maximum`	(Tensor self, Tensor other) → Tensor
`prims.minimum` （如果需要进一步解释其含义，请提供更多信息）	(Tensor self, Tensor other) → Tensor
`prims.mul`	(Tensor self, Tensor other) → Tensor
`prims.ne`	(Tensor self, Tensor other) → Tensor
`prims.nextafter`	(Tensor self, Tensor other) → Tensor
`prims.pow`	(Tensor self, Tensor other) → Tensor
`prims.remainder`	(Tensor self, Tensor other) → Tensor
`prims.rsqrt`	Tensor(self) → Tensor
`prims.shift_left`	(Tensor self, Tensor other) → Tensor
`prims.shift_right_arithmetic`	(Tensor self, Tensor other) → Tensor
`prims.sub`	(Tensor self, Tensor other) → Tensor
`prims.zeta`	(Tensor self, Tensor other) → Tensor
`prims.as_strided`	Tensor(a!) a, SymInt[] size, SymInt[] stride, SymInt storage_offset → Tensor(a!)
`prims.broadcast_in_dim`	(Tensor(a) a, SymInt[] shape, int[] broadcast_dimensions) -> Tensor(a)
`prims.collapse_view`	Tensor(a) a, int start, int end -> Tensor(a)
`prims.conj`	Tensor(a) a → Tensor(a)
`prims.slice`	(Tensor(a) a, SymInt[] start_indices, SymInt[] limit_indices, SymInt[] strides=None?) -> Tensor(a)
`prims.slice_in_dim`	Tensor(a) a, SymInt start_index, SymInt limit_index, int stride=1, int axis=0) -> Tensor(a)
`prims.split_dim`	Tensor(a) a, int dim, SymInt outer_length → Tensor(a)
`prims.squeeze`	(Tensor(a) a, int[] dimensions) -> Tensor(a)
`prims.transpose`	(Tensor(a) a, int[] permutation) -> Tensor(a)
`prims.view_of`	Tensor(a) a → Tensor(a)
`prims.view_of_dtype`	(Tensor(a) a, ScalarType dtype) -> Tensor(a)
`prims.as_strided_scatter`	(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt storage_offset) -> Tensor
`prims.collapse`	Tensor(a: Tensor, start: int, end: int) -> Tensor
`prims.cat`	(Tensor[] tensors, int dim) -> Tensor
`prims.reshape`	(Tensor a, SymInt[] shape) -> Tensor
`prims.reverse`	(Tensor a, int[] dims) -> Tensor
`prims.where`	(Tensor pred, Tensor a, Tensor b) → Tensor
`prims.clone`	(Tensor self, , memory_format=MemoryFormat.None) -> Tensor 为了更符合中文习惯，可以进一步调整为： Tensor self(内存格式: Optional[MemoryFormat] = None) -> Tensor 不过，根据提供的信息和保持原意的要求，直接翻译的话应该是： (张量 self, , memory_format=MemoryFormat?.None) -> 张量考虑到自然度，推荐使用第一种调整方式。如果需要严格遵循函数签名格式，则可以保留为原文的直接翻译形式。
`prims.convert_element_type`	(Tensor a, ScalarType dtype) → Tensor
`prims.device_put`	(Tensor a, Device device) → Tensor
`prims.item`	从张量 a 到标量的转换
`prims.maximum_value`	(ScalarType 类型) -> Scalar
`prims.minimum_value`	(ScalarType 类型) -> Scalar
`prims.copy_strided`	Tensor(a, SymInt[] stride) -> Tensor
`prims.copy_to`	(Tensor(a!) a, Tensor b) → Tensor(a!)
`prims.resize`	(Tensor(a!) a, SymInt[] shape) → Tensor(a!)
`prims.amax`	(Tensor inp, int[]? dims, *, ScalarType? output_dtype=None) -> Tensor
`prim's amin` 或者解释为：`prim's氨基` 具体取决于 "amin" 是否有特定含义，如果只是代码或标识符，则保持原样。这里根据常见理解建议修改为更易读的形式。但如果"prims.amin"是一个专有名词或者技术术语，则应保留原文。	(Tensor inp, int[]? dims, *, ScalarType? output_dtype=None) -> Tensor
`prims.prod`	(Tensor inp, int[]? dims, *, ScalarType? output_dtype=None) -> Tensor
`prims.sum`	(Tensor inp, int[]? dims, *, ScalarType? output_dtype=None) -> Tensor
`prims.xor_sum`	(Tensor inp, int[]? dims, *, ScalarType? output_dtype=None) -> Tensor
`prims.var`	(Tensor inp, int[]? dims, float? correction=1, *, ScalarType? output_dtype=None) -> Tensor
`prims.empty_strided`	(SymInt[] shape, SymInt[] strides, *, ScalarType dtype, Device device, bool requires_grad) -> Tensor
`prims.empty_permuted`	(SymInt[] shape, int[] physical_layout, *, ScalarType dtype, Device device, bool requires_grad) -> Tensor
`prims.scalar_tensor`	(标量 s, *, dtype 数据类型参数可选, device 设备参数可选) -> 张量
`prims.iota`	(SymInt length, *, SymInt start, SymInt step, ScalarType dtype, Device device, bool requires_grad) -> Tensor
`prims.svd`	(张量 A, *, bool full_matrices) → (张量 U, 张量 S, 张量 Vh)
`prims.normal`	(SymInt[] shape, *, Scalar mean, Scalar std, ScalarType dtype, Device device, bool requires_grad, Generator? generator=None) -> Tensor
`prims.uniform`	(SymInt[] shape, *, Scalar low, Scalar high, ScalarType dtype, Device device, Generator? generator=None) -> Tensor
`prims.fft_r2c`	(Tensor self, *, int[] dim, bool onesided) -> Tensor
`prims.fft_c2c`	(Tensor self, *, int[] dim, bool forward) → Tensor
`prims.fft_c2r`	(Tensor self, *, int[] dim, SymInt last_dim_size) -> Tensor
`prims._make_token`	() -> Tensor
`prims._sink_tokens`	（Tensor[] tokens）-> ()