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 相比，core aten ops 重用了 “native_functions.yaml” 中现有的 aten ops，并且没有将 ops 进一步分解为显式类型提升和广播 ops。此 opset 旨在用作与后端交互的功能性 IR。

警告

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

运算符	模式
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 input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor)
aten._native_batch_norm_legit.no_stats	_native_batch_norm_legit.no_stats(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, 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[1] output_size) -> Tensor
aten.add.Scalar	add.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor
aten.add.Tensor	add.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor
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, int[1] dim=[], bool 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, int? dim=None, bool keepdim=False) -> Tensor
aten.argmin	argmin(Tensor self, int? dim=None, bool keepdim=False) -> Tensor
aten.as_strided	as_strided(Tensor(a) self, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor(a)
aten.asin	asin(Tensor self) -> Tensor
aten.asinh	asinh(Tensor self) -> Tensor
aten.atan	atan(Tensor self) -> Tensor
aten.atan2	atan2(Tensor self, Tensor other) -> 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[1] kernel_size, int[1] stride=[], int[1] 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	bitwise_xor.Tensor(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, *, MemoryFormat? memory_format=None) -> Tensor
aten.col2im	col2im(张量 self, SymInt[2] 输出大小, int[2] 内核大小, int[2] 膨胀, int[2] 填充, int[2] 步长) -> 张量
aten.constant_pad_nd	constant_pad_nd(张量 self, SymInt[] 填充, 标量 value=0) -> 张量
aten.convolution	convolution(张量 输入, 张量 权重, 张量? 偏置, SymInt[] 步长, SymInt[] 填充, SymInt[] 膨胀, bool 转置, SymInt[] 输出填充, SymInt 组) -> 张量
aten.convolution_backward	convolution_backward(张量 梯度输出, 张量 输入, 张量 权重, SymInt[]? 偏置尺寸, SymInt[] 步长, SymInt[] 填充, SymInt[] 膨胀, bool 转置, SymInt[] 输出填充, SymInt 组, bool[3] 输出掩码) -> (张量, 张量, 张量)
aten.copy	copy(张量 self, 张量 源, bool 非阻塞=False) -> 张量
aten.cos	cos(张量 self) -> 张量
aten.cosh	cosh(张量 self) -> 张量
aten.cumsum	cumsum(张量 self, int 维度, *, 标量类型? dtype=None) -> 张量
aten.diagonal	diagonal(张量(a) self, int 偏移量=0, int 维度1=0, int 维度2=1) -> 张量(a)
aten.div.Scalar	div.Scalar(张量 self, 标量 其他) -> 张量
aten.div.Scalar_mode	div.Scalar_mode(张量 self, 标量 其他, *, str? 四舍五入模式) -> 张量
aten.div.Tensor	div.Tensor(张量 self, 张量 其他) -> 张量
aten.div.Tensor_mode	div.Tensor_mode(张量 self, 张量 其他, *, str? 四舍五入模式) -> 张量
aten.embedding	embedding(张量 权重, 张量 索引, SymInt 填充索引=-1, bool 按频率缩放梯度=False, bool 稀疏=False) -> 张量
aten.embedding_dense_backward	embedding_dense_backward(张量 梯度输出, 张量 索引, SymInt 权重数量, SymInt 填充索引, bool 按频率缩放梯度) -> 张量
aten.empty.memory_format	empty.memory_format(SymInt[] 大小, *, 标量类型? dtype=None, 布局? 布局=None, 设备? 设备=None, bool? 固定内存=None, 内存格式? 内存格式=None) -> 张量
aten.empty_strided	empty_strided(SymInt[] 大小, SymInt[] 步长, *, 标量类型? dtype=None, 布局? 布局=None, 设备? 设备=None, bool? 固定内存=None) -> 张量
aten.eq.Scalar	eq.Scalar(张量 self, 标量 其他) -> 张量
aten.eq.Tensor	eq.Tensor(张量 self, 张量 其他) -> 张量
aten.erf	erf(张量 self) -> 张量
aten.exp	exp(张量 self) -> 张量
aten.expand	expand(张量(a) self, SymInt[] 大小, *, bool 隐式=False) -> 张量(a)
aten.expm1	expm1(张量 self) -> 张量
aten.fill.Scalar	fill.Scalar(张量 self, 标量 值) -> 张量
aten.flip	flip(张量 self, int[] 维度) -> 张量
aten.floor	floor(张量 self) -> 张量
aten.fmod.Scalar	fmod.Scalar(张量 self, 标量 其他) -> 张量
aten.fmod.Tensor	fmod.Tensor(张量 self, 张量 其他) -> 张量
aten.full	full(SymInt[] 大小, 标量 填充值, *, 标量类型? dtype=None, 布局? 布局=None, 设备? 设备=None, bool? 固定内存=None) -> 张量
aten.gather	gather(张量 self, int 维度, 张量 索引, *, bool 稀疏梯度=False) -> 张量
aten.ge.Scalar	ge.Scalar(张量 self, 标量 其他) -> 张量
aten.ge.Tensor	ge.Tensor(张量 self, 张量 其他) -> 张量
aten.gelu	gelu(张量 self, *, str 近似值='none') -> 张量
aten.grid_sampler_2d	grid_sampler_2d(张量 输入, 张量 网格, int 插值模式, int 填充模式, bool 对齐角点) -> 张量
aten.gt.Scalar	gt.Scalar(张量 self, 标量 其他) -> 张量
aten.gt.Tensor	gt.Tensor(张量 self, 张量 其他) -> 张量
aten.hardtanh	hardtanh(张量 self, 标量 最小值=-1, 标量 最大值=1) -> 张量
aten.index.Tensor	index.Tensor(张量 self, 张量?[] 索引) -> 张量
aten.index_put	index_put(张量 self, 张量?[] 索引, 张量 值, bool 累加=False) -> 张量
aten.index_select	index_select(张量 self, int 维度, 张量 索引) -> 张量
aten.isinf	isinf(张量 self) -> 张量
aten.isnan	isnan(张量 self) -> 张量
aten.le.Scalar	le.Scalar(张量 self, 标量 其他) -> 张量
aten.le.Tensor	le.Tensor(张量 self, 张量 其他) -> 张量
aten.leaky_relu	leaky_relu(张量 self, 标量 负斜率=0.01) -> 张量
aten.log	log(张量 self) -> 张量
aten.log10	log10(张量 self) -> 张量
aten.log1p	log1p(张量 self) -> 张量
aten.log2	log2(张量 self) -> 张量
aten.logical_and	logical_and(张量 self, 张量 其他) -> 张量
aten.logical_not	logical_not(张量 self) -> 张量
aten.logical_or	logical_or(张量 self, 张量 其他) -> 张量
aten.logical_xor	logical_xor(张量 self, 张量 其他) -> 张量
aten.lt.Scalar	lt.Scalar(张量 self, 标量 其他) -> 张量
aten.lt.Tensor	lt.Tensor(张量 self, 张量 其他) -> 张量
aten.max.dim	max.dim(张量 self, int 维度, bool 保留维度=False) -> (张量 值, 张量 索引)
aten.max_pool2d_with_indices	max_pool2d_with_indices(张量 self, int[2] 内核大小, int[2] 步长=[], int[2] 填充=0, int[2] 膨胀=1, bool 上限模式=False) -> (张量, 张量)
aten.max_pool2d_with_indices_backward	max_pool2d_with_indices_backward(张量 梯度输出, 张量 self, int[2] 内核大小, int[2] 步长, int[2] 填充, int[2] 膨胀, bool 上限模式, 张量 索引) -> 张量
aten.max_pool3d_with_indices	max_pool3d_with_indices(张量 self, int[3] 内核大小, int[3] 步长=[], int[3] 填充=0, int[3] 膨胀=1, bool 上限模式=False) -> (张量, 张量)
aten.maximum	maximum(张量 self, 张量 其他) -> 张量
aten.mean	mean(张量 self, *, 标量类型? dtype=None) -> 张量
aten.mean.dim	mean.dim(张量 self, int[1]? 维度, bool 保留维度=False, *, 标量类型? dtype=None) -> 张量
aten.min.dim	min.dim(张量 self, int 维度, bool 保留维度=False) -> (张量 值, 张量 索引)
aten.minimum	minimum(张量 self, 张量 其他) -> 张量
aten.mm	mm(张量 self, 张量 mat2) -> 张量
aten.mul.Scalar	mul.Scalar(张量 self, 标量 其他) -> 张量
aten.mul.Tensor	mul.Tensor(张量 self, 张量 其他) -> 张量
aten.native_dropout	native_dropout(张量 输入, float p, bool? 训练) -> (张量, 张量)
aten.native_group_norm	native_group_norm(张量 输入, 张量? 权重, 张量? 偏置, SymInt N, SymInt C, SymInt HxW, int 组, float eps) -> (张量, 张量, 张量)
aten.native_group_norm_backward	native_group_norm_backward(张量 梯度输出, 张量 输入, 张量 均值, 张量 rstd, 张量? 权重, SymInt N, SymInt C, SymInt HxW, int 组, bool[3] 输出掩码) -> (张量, 张量, 张量)
aten.native_layer_norm	native_layer_norm(张量 输入, SymInt[] 标准化形状, 张量? 权重, 张量? 偏置, float eps) -> (张量, 张量, 张量)
aten.native_layer_norm_backward	native_layer_norm_backward(张量 梯度输出, 张量 输入, SymInt[] 标准化形状, 张量 均值, 张量 rstd, 张量? 权重, 张量? 偏置, bool[3] 输出掩码) -> (张量, 张量, 张量)
aten.ne.Scalar	ne.Scalar(张量 self, 标量 其他) -> 张量
aten.ne.Tensor	ne.Tensor(张量 self, 张量 其他) -> 张量
aten.neg	neg(张量 self) -> 张量
aten.nonzero	nonzero(张量 self) -> 张量
aten.permute	permute(张量(a) self, int[] 维度) -> 张量(a)
aten.pow.Scalar	pow.Scalar(标量 self, 张量 指数) -> 张量
aten.pow.Tensor_Scalar	pow.Tensor_Scalar(张量 self, 标量 指数) -> 张量
aten.pow.Tensor_Tensor	pow.Tensor_Tensor(张量 self, 张量 指数) -> 张量
aten.prod	prod(张量 self, *, 标量类型? dtype=None) -> 张量
aten.prod.dim_int	prod.dim_int(张量 self, int 维度, bool 保留维度=False, *, 标量类型? dtype=None) -> 张量
aten.rand	rand(SymInt[] 大小, *, 标量类型? dtype=None, 布局? 布局=None, 设备? 设备=None, bool? 固定内存=None) -> 张量
aten.randn	randn(SymInt[] 大小, *, 标量类型? dtype=None, 布局? 布局=None, 设备? 设备=None, bool? 固定内存=None) -> 张量
aten.randperm	randperm(SymInt n, *, 标量类型? dtype=long, 布局? 布局=None, 设备? 设备=None, bool? 固定内存=None) -> 张量
aten.reciprocal	reciprocal(张量 self) -> 张量
aten.reflection_pad1d	reflection_pad1d(张量 self, SymInt[2] 填充) -> 张量
aten.reflection_pad2d	reflection_pad2d(张量 self, SymInt[4] 填充) -> 张量
aten.reflection_pad3d	reflection_pad3d(张量 self, SymInt[6] 填充) -> 张量
aten.relu	relu(张量 self) -> 张量
aten.remainder.Scalar	remainder.Scalar(张量 self, 标量 其他) -> 张量
aten.remainder.Tensor	remainder.Tensor(张量 self, 张量 其他) -> 张量
aten.repeat	repeat(张量 self, SymInt[] 重复次数) -> 张量
aten.replication_pad2d	replication_pad2d(张量 self, SymInt[4] 填充) -> 张量
aten.replication_pad3d	replication_pad3d(张量 self, SymInt[6] 填充) -> 张量
aten.resize_	resize_(张量(a!) self, SymInt[] 大小, *, 内存格式? 内存格式=None) -> 张量(a!)
aten.round	round(张量 self) -> 张量
aten.rsqrt	rsqrt(张量 self) -> 张量
aten.scalar_tensor	scalar_tensor(标量 s, *, 标量类型? dtype=None, 布局? 布局=None, 设备? 设备=None, bool? 固定内存=None) -> 张量
aten.scatter.src	scatter.src(张量 self, int 维度, 张量 索引, 张量 源) -> 张量
aten.scatter.value	scatter.value(张量 self, int 维度, 张量 索引, 标量 值) -> 张量
aten.scatter_add	scatter_add(张量 self, int 维度, 张量 索引, 张量 源) -> 张量
aten.scatter_reduce.two	scatter_reduce.two(张量 self, int 维度, 张量 索引, 张量 源, str 减少, *, bool 包含自身=True) -> 张量
aten.select.int	select.int(张量(a) self, int 维度, SymInt 索引) -> 张量(a)
aten.select_scatter	select_scatter(张量 self, 张量 源, int 维度, SymInt 索引) -> 张量
aten.sigmoid	sigmoid(张量 self) -> 张量
aten.sign	sign(张量 self) -> 张量
aten.sin	sin(张量 self) -> 张量
aten.sinh	sinh(张量 self) -> 张量
aten.slice.Tensor	slice.Tensor(张量(a) self, int 维度=0, SymInt? 开始=None, SymInt? 结束=None, SymInt 步长=1) -> 张量(a)
aten.slice_scatter	slice_scatter(张量 self, 张量 源, int 维度=0, SymInt? 开始=None, SymInt? 结束=None, SymInt 步长=1) -> 张量
aten.sort	sort(张量 self, int 维度=-1, bool 降序=False) -> (张量 值, 张量 索引)
aten.split_with_sizes	split_with_sizes(张量(a -> *) self, SymInt[] 拆分尺寸, int 维度=0) -> 张量(a)[]
aten.sqrt	sqrt(张量 self) -> 张量
aten.squeeze.dim	squeeze.dim(张量(a) self, int 维度) -> 张量(a)
aten.squeeze.dims	squeeze.dims(张量(a) self, int[] 维度) -> 张量(a)
aten.sub.Scalar	sub.Scalar(张量 self, 标量 其他, 标量 alpha=1) -> 张量
aten.sub.Tensor	sub.Tensor(张量 self, 张量 其他, *, 标量 alpha=1) -> 张量
aten.sum.dim_IntList	sum.dim_IntList(张量 self, int[1]? 维度, bool 保留维度=False, *, 标量类型? dtype=None) -> 张量
aten.sym_numel	sym_numel(张量 self) -> SymInt
aten.sym_size.int	sym_size.int(张量 self, int 维度) -> SymInt
aten.sym_storage_offset	sym_storage_offset(张量 self) -> SymInt
aten.sym_stride.int	sym_stride.int(张量 self, int 维度) -> SymInt
aten.tan	tan(张量 self) -> 张量
aten.tanh	tanh(张量 self) -> 张量
aten.topk	topk(张量 self, SymInt k, int 维度=-1, bool 最大值=True, bool 排序=True) -> (张量 值, 张量 索引)
aten.trunc	trunc(张量 self) -> 张量
aten.unsqueeze	unsqueeze(张量(a) self, int 维度) -> 张量(a)
aten.upsample_bilinear2d.vec	upsample_bilinear2d.vec(张量 输入, SymInt[]? 输出大小, bool 对齐角点, float[]? 缩放因子) -> 张量
aten.upsample_nearest2d.vec	upsample_nearest2d.vec(张量 输入, SymInt[]? 输出大小, float[]? 缩放因子) -> 张量
aten.var.correction	var.correction(张量 self, int[1]? 维度=None, *, 标量? 校正=None, bool 保留维度=False) -> 张量
aten.var.dim	var.dim(张量 self, int[1]? 维度, bool 无偏=True, bool 保留维度=False) -> 张量
aten.view	view(张量(a) self, SymInt[] 大小) -> 张量(a)
aten.where.self	where.self(张量 条件, 张量 self, 张量 其他) -> 张量

Prims IR

Prims IR 是一组可以用来组合其他运算符的原始运算符。Prims IR 比 core aten IR 更底层，它将运算进一步分解为显式的类型提升和广播运算：prims.convert_element_type 和 prims.broadcast_in_dim。此运算符集旨在与编译器后端进行交互。

警告

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

运算符	模式
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 mantissa, Tensor exponent)
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.igammac	(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, int start, int end) -> Tensor
prims.cat	(Tensor[] tensors, int dim) -> Tensor
prims.reshape	(Tensor a, SymInt[] shape) -> Tensor
prims.rev	(Tensor a, int[] dims) -> Tensor
prims.where	(Tensor pred, Tensor a, Tensor b) -> Tensor
prims.clone	(Tensor self, *, MemoryFormat? memory_format=None) -> Tensor
prims.convert_element_type	(Tensor a, ScalarType dtype) -> Tensor
prims.device_put	(Tensor a, Device device) -> Tensor
prims.item	(Tensor a) -> Scalar
prims.maximum_value	(ScalarType dtype) -> Scalar
prims.minimum_value	(ScalarType dtype) -> 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
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	(Scalar s, *, ScalarType? dtype=None, Device? device=None) -> Tensor
prims.iota	(SymInt length, *, SymInt start, SymInt step, ScalarType dtype, Device device, bool requires_grad) -> Tensor
prims.svd	(Tensor A, *, bool full_matrices) -> (Tensor U, Tensor S, Tensor 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) -> ()