IRs

PyTorch 2.0 为后端提供了两组 IR 接口：Core Aten IR 和 Prims IR。

Core Aten IR

Core aten ops 是 aten 运算符的核心子集，可用于组合其他运算符。 Core aten IR 功能齐全，此 opset 中没有 inplace 或 _out 变体。 与 Prims IR 相比，核心 aten ops 重用了 “native_functions.yaml” 中现有的 aten ops。 它没有进一步将 Ops 分解为 Explicit type Promote 和 Broadcast Ops。 此 opset 旨在用作与后端接口的功能性 IR。

警告

此 opset 仍在积极开发中，未来将添加更多 ops。

算子	图式
aten._adaptive_avg_pool2d	_adaptive_avg_pool2d（Tensor self， SymInt[2] output_size） -> 张量
aten._adaptive_avg_pool2d_backward	_adaptive_avg_pool2d_backward（Tensor grad_output， Tensor self） -> Tensor
aten._log_softmax	_log_softmax（Tensor self， int dim， bool half_to_float） -> 张量
aten._native_batch_norm_legit.no_stats	_native_batch_norm_legit.no_stats（张量输入、张量权重、张量偏差、布尔训练、浮点动量、浮点 eps） -> （张量、张量、张量）
aten._softmax	_softmax（Tensor self， int dim， bool half_to_float） -> 张量
aten._to_copy	_to_copy（Tensor self， *， ScalarType？ dtype=无， 布局？ layout=无， device？ device=无， bool？ pin_memory=无， bool non_blocking=False， MemoryFormat memory_format=无） -> 张量
aten.abs	abs（Tensor self） -> 张量
aten.acos	acos（Tensor self） -> 张量
aten.acosh	acosh（Tensor self） -> 张量
aten.add.Scalar	加。Scalar（Tensor self， Scalar other， Scalar alpha=1） -> 张量
aten.add.Tensor	加。Tensor（Tensor self， Tensor other， *， 标量 alpha=1） -> 张量
aten.addmm	addmm（张量 self， 张量 mat1， 张量 mat2， *， 标量 beta=1， 标量 alpha=1） -> 张量
aten.alias	别名（张量（a） self） -> 张量（a）
aten.amax	amax（Tensor self， int[1] dim=[]， bool keepdim=False） -> 张量
aten.amin	amin（Tensor self， int[1] dim=[]， bool keepdim=False） -> 张量
aten.arange.start_step	arange.start_step（标量开始，标量结束，标量步长=1， *， ScalarType？ dtype=无， 布局？ layout=无， 设备？ device=无， bool？ pin_memory=无） -> 张量
aten.argmax	argmax（Tensor self， int？ dim=None， bool keepdim=False） -> 张量
aten.argmin	argmin（Tensor self， int？ dim=None， bool keepdim=False） -> 张量
aten.as_strided	as_strided（Tensor（a） self， SymInt[] 大小， SymInt[] 步幅， SymInt storage_offset=无） -> 张量 （a）
aten.asin	asin（Tensor self） -> 张量
aten.asinh	asinh（Tensor self） -> Tensor
aten.atan	atan（Tensor self） -> 张量
aten.atanh	atanh（Tensor self） -> 张量
aten.avg_pool2d	avg_pool2d（张量 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） -> 张量
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） -> 张量
aten.bitwise_and.Tensor	bitwise_and。Tensor(Tensor self, Tensor other) -> Tensor
aten.bitwise_not	bitwise_not（Tensor self） -> 张量
aten.bitwise_or.Tensor	bitwise_or。Tensor(Tensor self, Tensor other) -> Tensor
aten.bitwise_xor.Tensor	bitwise_xor。Tensor(Tensor self, Tensor other) -> Tensor
aten.bmm	bmm（Tensor self， Tensor mat2） -> 张量
aten.cat	cat（Tensor[] 张量， int dim=0） -> 张量
aten.clamp	clamp（Tensor self， Scalar？ min=None， Scalar？ max=None） -> 张量
aten.clone	clone（Tensor self， *， MemoryFormat？ memory_format=None） -> 张量
aten.col2im	col2im（张量 self， SymInt[2] output_size， int[2] kernel_size， int[2] 膨胀， int[2] 填充， int[2] 步幅） -> 张量
aten.constant_pad_nd	constant_pad_nd（Tensor self， SymInt[] pad， 标量值=0） -> 张量
aten.convolution	convolution（张量输入、张量权重、张量？偏差、int[] 步幅、SymInt[] 填充、int[] 膨胀、bool 转置、SymInt[] output_padding、int 组） -> 张量
aten.convolution_backward	convolution_backward（张量grad_output， 张量输入， 张量权重， SymInt[]？ bias_sizes， int[] 步幅， SymInt[] 填充， int[] 膨胀， bool 转置， SymInt[] output_padding， int 组， bool[3] output_mask） -> （张量， 张量， 张量）
aten.cos	cos（Tensor self） -> 张量
aten.cosh	cosh（Tensor self） -> 张量
aten.div.Scalar	div.Scalar（Tensor self， Scalar other） -> Tensor
aten.div.Tensor	div.Tensor（Tensor self， Tensor other） -> Tensor
aten.embedding_dense_backward	embedding_dense_backward（Tensor grad_output， Tensor indices， SymInt num_weights， SymInt padding_idx， bool scale_grad_by_freq） -> 张量
aten.empty_strided	empty_strided（SymInt[] 大小， SymInt[] 步幅， *， ScalarType？ dtype=无， 布局？ layout=无， 设备？ device=无， bool？ pin_memory=无） -> 张量
aten.eq.Scalar	情 商。Scalar（Tensor self， Scalar other） -> 张量
aten.eq.Tensor	情 商。Tensor(Tensor self, Tensor other) -> Tensor
aten.erf	erf（Tensor self） -> Tensor
aten.exp	exp（Tensor self） -> 张量
aten.expand	expand（Tensor（a） self， SymInt[] 大小， *， bool implicit=False） -> Tensor（a）
aten.fill.Scalar	填补。Scalar（Tensor self， Scalar value） -> 张量
aten.flip	flip（Tensor self， int[] dims） -> 张量
aten.floor	floor（Tensor self） -> 张量
aten.fmod.Tensor	fmod 的Tensor(Tensor self, Tensor other) -> Tensor
aten.full	full（SymInt[] 大小， 标量fill_value， *， ScalarType？ dtype=无， 布局？ layout=无， 设备？ device=无， bool？ pin_memory=无） -> 张量
aten.gather	gather（Tensor self， int dim， Tensor index， *， bool sparse_grad=False） -> 张量
aten.ge.Scalar	通用 电气。Scalar（Tensor self， Scalar other） -> 张量
aten.ge.Tensor	通用 电气。Tensor(Tensor self, Tensor other) -> Tensor
aten.gelu	gelu（Tensor self， *， str approximate='none'） -> 张量
aten.grid_sampler_2d	grid_sampler_2d（Tensor input， Tensor grid， int interpolation_mode， int padding_mode， bool align_corners） -> 张量
aten.gt.Scalar	燃气轮机。Scalar（Tensor self， Scalar other） -> 张量
aten.gt.Tensor	燃气轮机。Tensor(Tensor self, Tensor other) -> Tensor
aten.hardtanh	hardtanh（张量 self， 标量 min_val=-1， 标量 max_val=1） -> 张量
aten.index_select	index_select（Tensor self， int dim， Tensor index） -> 张量
aten.isinf	isinf（Tensor self） -> 张量
aten.isnan	isnan（Tensor self） -> 张量
aten.le.Scalar	乐。Scalar（Tensor self， Scalar other） -> 张量
aten.le.Tensor	乐。Tensor(Tensor self, Tensor other) -> Tensor
aten.leaky_relu	leaky_relu（Tensor self， Scalar negative_slope=0.01） -> 张量
aten.log	log（Tensor self） -> Tensor
aten.logical_and	logical_and（Tensor self， Tensor other） -> 张量
aten.logical_not	logical_not（Tensor self） -> 张量
aten.logical_or	logical_or（Tensor self， Tensor other） -> 张量
aten.lt.Scalar	中尉。Scalar（Tensor self， Scalar other） -> 张量
aten.lt.Tensor	中尉。Tensor(Tensor self, Tensor other) -> Tensor
aten.max.dim	max.dim （张量 self， int dim， bool keepdim=False） -> （张量值， 张量索引）
aten.max_pool2d_with_indices	max_pool2d_with_indices（张量 self， int[2] kernel_size， int[2] stride=[]， int[2] padding=0， int[2] dilation=1， bool ceil_mode=False） -> （张量， 张量）
aten.max_pool2d_with_indices_backward	max_pool2d_with_indices_backward（张量grad_output、张量自身、int[2] kernel_size、int[2] 步幅、int[2] 填充、int[2] 膨胀、bool ceil_mode、张量索引） -> 张量
aten.max_pool3d_with_indices	max_pool3d_with_indices（张量 self， int[3] kernel_size， int[3] stride=[]， int[3] padding=0， int[3] dilation=1， bool ceil_mode=False） -> （张量， 张量）
aten.maximum	maximum（Tensor self， Tensor other） -> 张量
aten.mean.dim	mean.dim（Tensor self， int[1]？ dim， bool keepdim=False， *， ScalarType？ dtype=None） -> 张量
aten.min.dim	min.dim（张量 self， int dim， bool keepdim=False） -> （张量值， 张量索引）
aten.minimum	minimum（Tensor self， Tensor other） -> 张量
aten.mm	mm（Tensor self， Tensor mat2） -> 张量
aten.mul.Scalar	穆尔。Scalar（Tensor self， Scalar other） -> 张量
aten.mul.Tensor	穆尔。Tensor(Tensor self, Tensor other) -> Tensor
aten.native_batch_norm	native_batch_norm（张量输入、张量？权重、张量？偏置、张量running_mean、张量running_var、布尔训练、浮点动量、浮点 eps）->（张量、张量、张量）
aten.native_dropout	native_dropout（Tensor input， float p， bool？ train） -> （Tensor， Tensor）
aten.native_group_norm	native_group_norm（张量输入、张量权重、张量？偏置、SymInt N、SymInt C、SymInt HxW、int 组、浮点 eps）->（张量、张量、张量）
aten.native_group_norm_backward	native_group_norm_backward（张量grad_out，张量输入，张量均值，张量rstd，张量？权重，SymInt N，SymInt C，SymInt HxW，int 组，bool[3] output_mask） -> （张量，张量，张量）
aten.native_layer_norm	native_layer_norm（张量输入， SymInt[] normalized_shape， 张量权重， 张量？ 偏差， 浮点 eps） -> （张量， 张量， 张量）
aten.native_layer_norm_backward	native_layer_norm_backward（张量grad_out，张量输入，SymInt[] normalized_shape，张量均值，张量rstd，张量？权重，张量？偏差，bool[3] output_mask） -> （张量，张量，张量）
aten.ne.Scalar	ne.Scalar（Tensor self， Scalar other） -> 张量
aten.ne.Tensor	ne.Tensor(Tensor self, Tensor other) -> Tensor
aten.neg	neg（Tensor self） -> 张量
aten.nonzero	nonzero（Tensor self） -> 张量
aten.permute	permute（Tensor（a） self， int[] dims） -> 张量（a）
aten.pow.Tensor_Scalar	战俘。Tensor_Scalar（Tensor self， Scalar exponent） -> 张量
aten.pow.Tensor_Tensor	战俘。Tensor_Tensor(Tensor self, Tensor exponent) -> Tensor
aten.reciprocal	reciprocal（Tensor self） -> 张量
aten.reflection_pad2d	reflection_pad2d（Tensor self， SymInt[4] padding） -> 张量
aten.relu	relu（Tensor self） -> Tensor
aten.remainder.Tensor	剩余。Tensor(Tensor self, Tensor other) -> Tensor
aten.repeat	repeat（Tensor self， SymInt[] repeats） -> 张量
aten.replication_pad2d	replication_pad2d（Tensor self， SymInt[4] padding） -> 张量
aten.replication_pad3d	replication_pad3d（Tensor self， SymInt[6] padding） -> 张量
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） -> 张量
aten.scatter_add	scatter_add（Tensor self， int dim， Tensor index， Tensor src） -> 张量
aten.scatter_reduce.two	scatter_reduce.two（Tensor self， int dim， Tensor index， Tensor src， str reduce， *， bool include_self=True） -> 张量
aten.select.int	select.int（Tensor（a） self， int dim， SymInt index） -> Tensor（a）
aten.sigmoid	sigmoid（Tensor self） -> 张量
aten.sign	sign（Tensor self） -> Tensor
aten.sin	sin（Tensor self） -> 张量
aten.sinh	sinh（Tensor self） -> Tensor
aten.slice.Tensor	片。Tensor（Tensor（a） self， int dim=0， SymInt？ start=None， SymInt？ end=None， SymInt step=1） -> 张量（a）
aten.slice_scatter	slice_scatter（张量 self， 张量 src， int dim=0， SymInt？ start=None， SymInt？ end=None， SymInt step=1） -> 张量
aten.sqrt	sqrt（Tensor self） -> 张量
aten.squeeze.dim	squeeze.dim（Tensor（a） self， int dim） -> 张量 （a）
aten.squeeze.dims	squeeze.dims（Tensor（a） self， int[] dim） -> 张量（a）
aten.sub.Scalar	子。Scalar（Tensor self， Scalar other， Scalar alpha=1） -> 张量
aten.sub.Tensor	子。Tensor（Tensor self， Tensor other， *， 标量 alpha=1） -> 张量
aten.sum.dim_IntList	sum.dim_IntList（Tensor self， int[1]？ dim， bool keepdim=False， *， ScalarType？ dtype=None） -> 张量
aten.tanh	tanh（Tensor self） -> Tensor
aten.topk	topk（张量 self， int k， int dim=-1， bool largest=True， bool sorted=True） -> （张量值， 张量索引）
aten.unsqueeze	unsqueeze（张量（a） self， int dim） -> 张量（a）
aten.upsample_bilinear2d.vec	upsample_bilinear2d.vec（Tensor input， SymInt[]？ output_size， bool align_corners， float[]？ scale_factors） -> 张量
aten.upsample_nearest2d.vec	upsample_nearest2d.vec（Tensor input， SymInt[]？ output_size， float[]？ scale_factors） -> 张量
aten.var.dim	var.dim（Tensor self， int[1]？ dim， bool unbiased=True， bool keepdim=False） -> 张量
aten.view	view（Tensor（a） self， SymInt[] 大小） -> Tensor（a）
aten.where.self	where.self（Tensor condition， Tensor self， Tensor other） -> Tensor

Prims IR

Prims IR 是一组基元运算符，可用于组合其他运算符。 Prims IR 是比 core aten IR 级别更低的 opset，它进一步将 ops 分解为 explicit 类型 Promotion and Broadcasting Ops： prims.convert_element_type 和 prims.broadcast_in_dim。 此 opset 旨在与编译器后端交互。

警告

此 opset 仍在积极开发中，未来将添加更多 ops。

算子	图式
prims.abs	abs（Tensor self） -> 张量
prims.acos	acos（Tensor self） -> 张量
prims.acosh	acosh（Tensor self） -> 张量
prims.asin	asin（Tensor self） -> 张量
prims.asinh	asinh（Tensor self） -> Tensor
prims.atan	atan（Tensor self） -> 张量
prims.atanh	atanh（Tensor self） -> 张量
prims.cos	cos（Tensor self） -> 张量
prims.cosh	cosh（Tensor self） -> 张量
prims.bessel_i0	bessel_i0（Tensor self） -> 张量
prims.bessel_i0e	bessel_i0e（Tensor self） -> Tensor
prims.bessel_i1	bessel_i1（Tensor self） -> 张量
prims.bessel_i1e	bessel_i1e（Tensor self） -> 张量
prims.bessel_j0	bessel_j0（Tensor self） -> 张量
prims.bessel_j1	bessel_j1（Tensor self） -> 张量
prims.bitwise_not	bitwise_not（Tensor self） -> 张量
prims.cbrt	cbrt（Tensor self） -> 张量
prims.ceil	ceil（Tensor self） -> 张量
prims.conj_physical	conj_physical（Tensor self） -> 张量
prims.digamma	digamma（Tensor self） -> 张量
prims.erf	erf（Tensor self） -> Tensor
prims.erf_inv	erf_inv（Tensor self） -> 张量
prims.erfc	erfc（Tensor self） -> 张量
prims.erfcx	erfcx（Tensor self） -> Tensor
prims.exp	exp（Tensor self） -> 张量
prims.expm1	expm1（Tensor self） -> Tensor
prims.exp2	exp2（Tensor self） -> 张量
prims.fill	fill（Tensor self， Scalar value） -> 张量
prims.floor	floor（Tensor self） -> 张量
prims.imag	imag（Tensor self） -> 张量
prims.isfinite	isfinite（Tensor self） -> 张量
prims.lgamma	lgamma（Tensor self） -> 张量
prims.log	log（Tensor self） -> Tensor
prims.log1p	log1p（Tensor self） -> Tensor
prims.log2	log2（Tensor self） -> Tensor
prims.log10	log10（Tensor self） -> Tensor
prims.ndtri	ndtri（Tensor self） -> 张量
prims.neg	neg（Tensor self） -> 张量
prims.real	real（Tensor self） -> 张量
prims.reciprocal	reciprocal（Tensor self） -> 张量
prims.round	round（Tensor self） -> 张量
prims.sign	sign（Tensor self） -> Tensor
prims.signbit	signbit（Tensor self） -> Tensor
prims.sin	sin（Tensor self） -> 张量
prims.sinh	sinh（Tensor self） -> Tensor
prims.spherical_bessel_j0	spherical_bessel_j0（Tensor self） -> 张量
prims.sqrt	sqrt（Tensor self） -> 张量
prims.tan	tan（Tensor self） -> 张量
prims.tanh	tanh（Tensor self） -> Tensor
prims.trunc	trunc（Tensor self） -> Tensor
prims.add	add（Tensor self， Tensor other） -> Tensor
prims.atan2	atan2（Tensor self， Tensor other） -> 张量
prims.bitwise_and	bitwise_and（Tensor self， Tensor other） -> 张量
prims.bitwise_or	bitwise_or（Tensor self， Tensor other） -> Tensor
prims.bitwise_xor	bitwise_xor（Tensor self， Tensor other） -> Tensor
prims.div	div（Tensor self， Tensor other） -> Tensor
prims.eq	eq（Tensor self， Tensor other） -> Tensor
prims.fmax	fmax（Tensor self， Tensor other） -> Tensor
prims.fmin	fmin（Tensor self， Tensor other） -> 张量
prims.fmod	fmod（Tensor self， Tensor other） -> 张量
prims.gcd	gcd（Tensor self， Tensor other） -> Tensor
prims.ge	ge（Tensor self， Tensor other） -> 张量
prims.gt	gt（Tensor self， Tensor other） -> 张量
prims.hypot	hypot（Tensor self， Tensor other） -> 张量
prims.igamma	igamma（Tensor self， Tensor other） -> 张量
prims.igammac	igammac（Tensor self， Tensor other） -> 张量
prims.le	le（Tensor self， Tensor other） -> 张量
prims.lt	lt（Tensor self， Tensor other） -> 张量
prims.maximum	maximum（Tensor self， Tensor other） -> 张量
prims.minimum	minimum（Tensor self， Tensor other） -> 张量
prims.mul	mul（Tensor self， Tensor other） -> 张量
prims.ne	ne（Tensor self， Tensor other） -> Tensor
prims.nextafter	nextafter（Tensor self， Tensor other） -> 张量
prims.pow	pow（Tensor self， Tensor other） -> 张量
prims.remainder	remainder（Tensor self， Tensor other） -> 张量
prims.rsqrt	rsqrt（Tensor self） -> Tensor
prims.shift_left	shift_left（Tensor self， Tensor other） -> 张量
prims.shift_right_arithmetic	shift_right_arithmetic（Tensor self， Tensor other） -> 张量
prims.sub	sub（Tensor self， Tensor other） -> Tensor
prims.zeta	zeta（Tensor self， Tensor other） -> 张量
prims.as_strided	as_strided（Tensor（a！） a， SymInt[] 大小， SymInt[] 步幅， SymInt storage_offset） -> Tensor（a！）
prims.broadcast_in_dim	broadcast_in_dim（Tensor（a） a， SymInt[] 形状， int[] broadcast_dimensions） -> Tensor（a）
prims.collapse_view	collapse_view（张量 （a） a， int start， int end） -> 张量 （a）
prims.conj	conj（张量（a） a） -> 张量（a）
prims.slice	slice（Tensor（a） a， SymInt[] start_indices， SymInt[] limit_indices， SymInt[]？ strides=None） -> 张量（a）
prims.slice_in_dim	slice_in_dim（张量 （a） a， SymInt start_index， SymInt limit_index， int stride=1， int axis=0） -> 张量 （a）
prims.split_dim	split_dim（张量 （a） a， int dim， SymInt outer_length） -> 张量 （a）
prims.squeeze	squeeze（张量（a） a， int[] 维度） -> 张量（a）
prims.transpose	transpose（张量（a） a， int[] 排列） -> 张量（a）
prims.view_of	view_of（Tensor（a） a） -> 张量
prims.as_strided_scatter	as_strided_scatter（Tensor self， Tensor src， SymInt[] size， SymInt[] stride， SymInt storage_offset） -> 张量
prims.cat	cat（Tensor[] 张量， int dim） -> 张量
prims.reshape	reshape（Tensor a， SymInt[] shape） -> 张量
prims.rev	rev（Tensor a， int[] dims） -> 张量
prims.where	其中（Tensor pred， Tensor a， Tensor b） -> 张量
prims.clone	clone（Tensor self， *， MemoryFormat？ memory_format=None） -> 张量
prims.convert_element_type	convert_element_type（Tensor a， ScalarType dtype） -> 张量
prims.device_put	device_put（Tensor a， Device device） -> 张量
prims.item	item（Tensor a） -> 标量
prims.maximum_value	maximum_value（ScalarType dtype） -> 标量
prims.minium_value	minium_value（ScalarType dtype） -> 标量
prims.copy_strided	copy_strided（Tensor a， SymInt[] stride） -> 张量
prims.copy_to	copy_to（张量 （a！） a， 张量 b） -> 张量 （a！）
prims.resize	resize（Tensor（a！） a， SymInt[] 形状） -> Tensor（a！）
prims.amax	amax（Tensor inp， int[]？ dims， *， ScalarType？ output_dtype=None） -> 张量
prims.amin	amin（Tensor inp， int[]？ dims， *， ScalarType？ output_dtype=None） -> 张量
prims.prod	prod（Tensor inp， int[]？ dims， *， ScalarType？ output_dtype=None） -> 张量
prims.sum	sum（Tensor inp， int[]？ dims， *， ScalarType？ output_dtype=None） -> 张量
prims.var	var（Tensor inp， int[]？ dims， *， int correction， ScalarType？ output_dtype=None） -> 张量
prims.empty_strided	empty_strided（SymInt[] 形状， SymInt[] 步幅， *， ScalarType dtype， 设备设备， bool requires_grad） -> 张量
prims.scalar_tensor	scalar_tensor（Scalar s， *， ScalarType？ dtype=None， Device？ device=None） -> 张量
prims.iota	iota（SymInt length， *， SymInt start， SymInt step， ScalarType dtype， Device device， bool requires_grad） -> 张量
prims.svd	svd（张量 A， *， bool full_matrices） -> （张量 U， 张量 S， 张量 Vh）
prims.normal	normal（SymInt[] 形状， *， 标量平均值， 标量标准， 标量类型 dtype， 设备设备， bool requires_grad） -> 张量
prims.uniform	uniform（SymInt[] 形状， *， 标量低， 标量高， ScalarType dtype， 设备设备） -> 张量
prims.fft_r2c	fft_r2c（Tensor self， *， int[] dim， bool onesided） -> 张量
prims.fft_c2c	fft_c2c（Tensor self， *， int[] dim， bool forward） -> 张量
prims.fft_c2r	fft_c2r（Tensor self， *， int[] dim， SymInt last_dim_size） -> 张量