Skip to content

Commit 0c340b4

Browse files
narendasannarendasan
committed
docs: Adding a list of currently supported ops
Signed-off-by: Naren Dasan <[email protected]> Signed-off-by: Naren Dasan <[email protected]>
1 parent 872d9a3 commit 0c340b4

File tree

4 files changed

+220
-0
lines changed

4 files changed

+220
-0
lines changed

‎cpp/supportedops/main.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,8 @@ int main(int argc, const char* argv[]) {
1313
std::stringstream ss;
1414

1515
ss << R"TITLE(
16+
.. _supported_ops:
17+
1618
=================================
1719
Operators Supported
1820
=================================

‎docsrc/index.rst

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,15 @@ Contributor Documentation
9393
Indices
9494
----------------
9595

96+
* :ref:`supported_operators`
97+
98+
.. toctree::
99+
:caption: Indices
100+
:maxdepth: 1
101+
:hidden:
102+
103+
indices/supported_ops
104+
96105
* :ref:`genindex`
97106
* :ref:`search`
98107

‎docsrc/indices/.gitkeep

Whitespace-only changes.

‎docsrc/indices/supported_ops.rst

Lines changed: 209 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,209 @@
1+
2+
.. _supported_ops:
3+
4+
=================================
5+
Operators Supported
6+
=================================
7+
8+
9+
Operators Currently Supported Through Converters
10+
-------------------------------------------------
11+
12+
- aten::_convolution(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) -> (Tensor)
13+
- aten::_convolution.deprecated(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled) -> (Tensor)
14+
- aten::abs(Tensor self) -> (Tensor)
15+
- aten::acos(Tensor self) -> (Tensor)
16+
- aten::acosh(Tensor self) -> (Tensor)
17+
- aten::adaptive_avg_pool2d(Tensor self, int[2] output_size) -> (Tensor)
18+
- aten::add.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> (Tensor)
19+
- aten::add.Tensor(Tensor self, Tensor other, Scalar alpha=1) -> (Tensor)
20+
- aten::add_.Tensor(Tensor(a!) self, Tensor other, *, Scalar alpha=1) -> (Tensor(a!))
21+
- aten::asin(Tensor self) -> (Tensor)
22+
- aten::asinh(Tensor self) -> (Tensor)
23+
- aten::atan(Tensor self) -> (Tensor)
24+
- aten::atanh(Tensor self) -> (Tensor)
25+
- aten::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)
26+
- aten::avg_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=[0, 0], bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None) -> (Tensor)
27+
- aten::avg_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=[], bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None) -> (Tensor)
28+
- aten::batch_norm(Tensor input, Tensor? gamma, Tensor? beta, Tensor? mean, Tensor? var, bool training, float momentum, float eps, bool cudnn_enabled) -> (Tensor)
29+
- aten::cat(Tensor[] tensors, int dim=0) -> (Tensor)
30+
- aten::ceil(Tensor self) -> (Tensor)
31+
- aten::clamp(Tensor self, Scalar? min=None, Scalar? max=None) -> (Tensor)
32+
- aten::cos(Tensor self) -> (Tensor)
33+
- aten::cosh(Tensor self) -> (Tensor)
34+
- aten::div.Scalar(Tensor self, Scalar other) -> (Tensor)
35+
- aten::div.Tensor(Tensor self, Tensor other) -> (Tensor)
36+
- aten::div_.Scalar(Tensor(a!) self, Scalar other) -> (Tensor(a!))
37+
- aten::div_.Tensor(Tensor(a!) self, Tensor other) -> (Tensor(a!))
38+
- aten::embedding(Tensor weight, Tensor indices, int padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False) -> (Tensor)
39+
- aten::eq.Scalar(Tensor self, Scalar other) -> (Tensor)
40+
- aten::eq.Tensor(Tensor self, Tensor other) -> (Tensor)
41+
- aten::erf(Tensor self) -> (Tensor)
42+
- aten::exp(Tensor self) -> (Tensor)
43+
- aten::expand(Tensor(a) self, int[] size, *, bool implicit=False) -> (Tensor(a))
44+
- aten::expand_as(Tensor(a) self, Tensor other) -> (Tensor(a))
45+
- aten::flatten.using_ints(Tensor self, int start_dim=0, int end_dim=-1) -> (Tensor)
46+
- aten::floor(Tensor self) -> (Tensor)
47+
- aten::floor_divide(Tensor self, Tensor other) -> (Tensor)
48+
- aten::floor_divide.Scalar(Tensor self, Scalar other) -> (Tensor)
49+
- aten::ge.Scalar(Tensor self, Scalar other) -> (Tensor)
50+
- aten::ge.Tensor(Tensor self, Tensor other) -> (Tensor)
51+
- aten::gt.Scalar(Tensor self, Scalar other) -> (Tensor)
52+
- aten::gt.Tensor(Tensor self, Tensor other) -> (Tensor)
53+
- aten::hardtanh(Tensor self, Scalar min_val=-1, Scalar max_val=1) -> (Tensor)
54+
- aten::hardtanh_(Tensor(a!) self, Scalar min_val=-1, Scalar max_val=1) -> (Tensor(a!))
55+
- aten::le.Scalar(Tensor self, Scalar other) -> (Tensor)
56+
- aten::le.Tensor(Tensor self, Tensor other) -> (Tensor)
57+
- aten::leaky_relu(Tensor self, Scalar negative_slope=0.01) -> (Tensor)
58+
- aten::leaky_relu_(Tensor(a!) self, Scalar negative_slope=0.01) -> (Tensor(a!))
59+
- aten::linear(Tensor input, Tensor weight, Tensor? bias=None) -> (Tensor)
60+
- aten::log(Tensor self) -> (Tensor)
61+
- aten::lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> (Tensor, Tensor)
62+
- aten::lt.Scalar(Tensor self, Scalar other) -> (Tensor)
63+
- aten::lt.Tensor(Tensor self, Tensor other) -> (Tensor)
64+
- aten::matmul(Tensor self, Tensor other) -> (Tensor)
65+
- aten::max(Tensor self) -> (Tensor)
66+
- aten::max.other(Tensor self, Tensor other) -> (Tensor)
67+
- aten::max_pool1d(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=[], int[1] dilation=[], bool ceil_mode=False) -> (Tensor)
68+
- aten::max_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=[0, 0], int[2] dilation=[1, 1], bool ceil_mode=False) -> (Tensor)
69+
- aten::max_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=[], int[3] dilation=[], bool ceil_mode=False) -> (Tensor)
70+
- aten::mean(Tensor self, *, int? dtype=None) -> (Tensor)
71+
- aten::mean.dim(Tensor self, int[] dim, bool keepdim=False, *, int? dtype=None) -> (Tensor)
72+
- aten::min(Tensor self) -> (Tensor)
73+
- aten::min.other(Tensor self, Tensor other) -> (Tensor)
74+
- aten::mul.Tensor(Tensor self, Tensor other) -> (Tensor)
75+
- aten::mul_.Tensor(Tensor(a!) self, Tensor other) -> (Tensor(a!))
76+
- aten::narrow(Tensor(a) self, int dim, int start, int length) -> (Tensor(a))
77+
- aten::narrow.Tensor(Tensor(a) self, int dim, Tensor start, int length) -> (Tensor(a))
78+
- aten::ne.Scalar(Tensor self, Scalar other) -> (Tensor)
79+
- aten::ne.Tensor(Tensor self, Tensor other) -> (Tensor)
80+
- aten::neg(Tensor self) -> (Tensor)
81+
- aten::permute(Tensor(a) self, int[] dims) -> (Tensor(a))
82+
- aten::pow.Tensor_Scalar(Tensor self, Scalar exponent) -> (Tensor)
83+
- aten::pow.Tensor_Tensor(Tensor self, Tensor exponent) -> (Tensor)
84+
- aten::prelu(Tensor self, Tensor weight) -> (Tensor)
85+
- aten::prod(Tensor self, *, int? dtype=None) -> (Tensor)
86+
- aten::prod.dim_int(Tensor self, int dim, bool keepdim=False, *, int? dtype=None) -> (Tensor)
87+
- aten::reciprocal(Tensor self) -> (Tensor)
88+
- aten::relu(Tensor input) -> (Tensor)
89+
- aten::relu_(Tensor(a!) self) -> (Tensor(a!))
90+
- aten::repeat(Tensor self, int[] repeats) -> (Tensor)
91+
- aten::reshape(Tensor self, int[] shape) -> (Tensor)
92+
- aten::rsub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> (Tensor)
93+
- aten::rsub.Tensor(Tensor self, Tensor other, Scalar alpha=1) -> (Tensor)
94+
- aten::select.int(Tensor(a) self, int dim, int index) -> (Tensor(a))
95+
- aten::sigmoid(Tensor input) -> (Tensor)
96+
- aten::sigmoid_(Tensor(a!) self) -> (Tensor(a!))
97+
- aten::sin(Tensor self) -> (Tensor)
98+
- aten::sinh(Tensor self) -> (Tensor)
99+
- aten::slice.Tensor(Tensor(a) self, int dim=0, int start=0, int end=9223372036854775807, int step=1) -> (Tensor(a))
100+
- aten::softmax.int(Tensor self, int dim, int? dtype=None) -> (Tensor)
101+
- aten::split(Tensor self, int[] split_sizes, int dim=0) -> (Tensor[])
102+
- aten::split.Tensor(Tensor(a) self, int split_size, int dim=0) -> (Tensor[])
103+
- aten::split_with_sizes(Tensor(a) self, int[] split_sizes, int dim=0) -> (Tensor[])
104+
- aten::sqrt(Tensor self) -> (Tensor)
105+
- aten::squeeze.dim(Tensor(a) self, int dim) -> (Tensor(a))
106+
- aten::stack(Tensor[] tensors, int dim=0) -> (Tensor)
107+
- aten::sub.Tensor(Tensor self, Tensor other, Scalar alpha=1) -> (Tensor)
108+
- aten::sub_.Tensor(Tensor(a!) self, Tensor other, *, Scalar alpha=1) -> (Tensor(a!))
109+
- aten::sum(Tensor self, *, int? dtype=None) -> (Tensor)
110+
- aten::sum.dim_IntList(Tensor self, int[1] dim, bool keepdim=False, *, int? dtype=None) -> (Tensor)
111+
- aten::tan(Tensor self) -> (Tensor)
112+
- aten::tanh(Tensor input) -> (Tensor)
113+
- aten::tanh_(Tensor(a!) self) -> (Tensor(a!))
114+
- aten::topk(Tensor self, int k, int dim=-1, bool largest=True, bool sorted=True) -> (Tensor values, Tensor indices)
115+
- aten::unsqueeze(Tensor(a) self, int dim) -> (Tensor(a))
116+
- aten::upsample_bilinear2d(Tensor self, int[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> (Tensor)
117+
- aten::upsample_bilinear2d.vec(Tensor input, int[]? output_size, bool align_corners, float[]? scale_factors) -> (Tensor)
118+
- aten::upsample_linear1d(Tensor self, int[1] output_size, bool align_corners, float? scales=None) -> (Tensor)
119+
- aten::upsample_linear1d.vec(Tensor input, int[]? output_size, bool align_corners, float[]? scale_factors) -> (Tensor)
120+
- aten::upsample_nearest1d(Tensor self, int[1] output_size, float? scales=None) -> (Tensor)
121+
- aten::upsample_nearest1d.vec(Tensor input, int[]? output_size, float[]? scale_factors) -> (Tensor)
122+
- aten::upsample_nearest2d(Tensor self, int[2] output_size, float? scales_h=None, float? scales_w=None) -> (Tensor)
123+
- aten::upsample_nearest2d.vec(Tensor input, int[]? output_size, float[]? scale_factors) -> (Tensor)
124+
- aten::upsample_nearest3d(Tensor self, int[3] output_size, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> (Tensor)
125+
- aten::upsample_nearest3d.vec(Tensor input, int[]? output_size, float[]? scale_factors) -> (Tensor)
126+
- aten::upsample_trilinear3d(Tensor self, int[3] output_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> (Tensor)
127+
- aten::upsample_trilinear3d.vec(Tensor input, int[]? output_size, bool align_corners, float[]? scale_factors) -> (Tensor)
128+
- aten::view(Tensor(a) self, int[] size) -> (Tensor(a))
129+
- trt::const(Tensor self) -> (Tensor)
130+
131+
Operators Currently Supported Through Evaluators
132+
-------------------------------------------------
133+
134+
- aten::Bool.float(float b) -> (bool)
135+
- aten::Bool.int(int a) -> (bool)
136+
- aten::Float.Scalar(Scalar a) -> float
137+
- aten::Float.bool(bool a) -> float
138+
- aten::Float.int(int a) -> float
139+
- aten::__and__(int a, int b) -> (bool)
140+
- aten::__getitem__.t(t[](a) list, int idx) -> (t(*))
141+
- aten::__is__(t1 self, t2 obj) -> bool
142+
- aten::__isnot__(t1 self, t2 obj) -> bool
143+
- aten::__not__(bool self) -> bool
144+
- aten::__or__(int a, int b) -> (bool)
145+
- aten::__round_to_zero_floordiv(int a, int b) -> (int)
146+
- aten::__xor__(int a, int b) -> (bool)
147+
- aten::add.float(float a, float b) -> (float)
148+
- aten::add.int(int a, int b) -> (int)
149+
- aten::add_.t(t[](a!) self, t[] b) -> (t[])
150+
- aten::append.t(t[](a!) self, t(c -> *) el) -> (t[](a!))
151+
- aten::dim(Tensor self) -> int
152+
- aten::div.float(float a, float b) -> (float)
153+
- aten::div.int(int a, int b) -> (float)
154+
- aten::eq.bool(bool a, bool b) -> (bool)
155+
- aten::eq.float(float a, float b) -> (bool)
156+
- aten::eq.float_int(float a, int b) -> (bool)
157+
- aten::eq.int(int a, int b) -> (bool)
158+
- aten::eq.int_float(int a, float b) -> (bool)
159+
- aten::floor.float(float a) -> (int)
160+
- aten::floordiv.float(float a, float b) -> (int)
161+
- aten::floordiv.int(int a, int b) -> (int)
162+
- aten::ge.bool(bool a, bool b) -> (bool)
163+
- aten::ge.float(float a, float b) -> (bool)
164+
- aten::ge.float_int(float a, int b) -> (bool)
165+
- aten::ge.int(int a, int b) -> (bool)
166+
- aten::ge.int_float(int a, float b) -> (bool)
167+
- aten::gt.bool(bool a, bool b) -> (bool)
168+
- aten::gt.float(float a, float b) -> (bool)
169+
- aten::gt.float_int(float a, int b) -> (bool)
170+
- aten::gt.int(int a, int b) -> (bool)
171+
- aten::gt.int_float(int a, float b) -> (bool)
172+
- aten::le.bool(bool a, bool b) -> (bool)
173+
- aten::le.float(float a, float b) -> (bool)
174+
- aten::le.float_int(float a, int b) -> (bool)
175+
- aten::le.int(int a, int b) -> (bool)
176+
- aten::le.int_float(int a, float b) -> (bool)
177+
- aten::len.t(t[] a) -> (int)
178+
- aten::lt.bool(bool a, bool b) -> (bool)
179+
- aten::lt.float(float a, float b) -> (bool)
180+
- aten::lt.float_int(float a, int b) -> (bool)
181+
- aten::lt.int(int a, int b) -> (bool)
182+
- aten::lt.int_float(int a, float b) -> (bool)
183+
- aten::mul.float(float a, float b) -> (float)
184+
- aten::mul.int(int a, int b) -> (int)
185+
- aten::ne.bool(bool a, bool b) -> (bool)
186+
- aten::ne.float(float a, float b) -> (bool)
187+
- aten::ne.float_int(float a, int b) -> (bool)
188+
- aten::ne.int(int a, int b) -> (bool)
189+
- aten::ne.int_float(int a, float b) -> (bool)
190+
- aten::neg.int(int a) -> (int)
191+
- aten::numel(Tensor self) -> int
192+
- aten::size(Tensor self) -> (int[])
193+
- aten::size.int(Tensor self, int dim) -> (int)
194+
- aten::slice.t(t[] l, int start, int end=9223372036854775807, int step=1) -> (t[])
195+
- aten::sub.float(float a, float b) -> (float)
196+
- aten::sub.int(int a, int b) -> (int)
197+
- prim::max.bool(bool a, bool b) -> (bool)
198+
- prim::max.float(float a, float b) -> (bool)
199+
- prim::max.float_int(float a, int b) -> (bool)
200+
- prim::max.int(int a, int b) -> (bool)
201+
- prim::max.int_float(int a, float b) -> (bool)
202+
- prim::max.self_int(int[] self) -> (int)
203+
- prim::min.bool(bool a, bool b) -> (bool)
204+
- prim::min.float(float a, float b) -> (bool)
205+
- prim::min.float_int(float a, int b) -> (bool)
206+
- prim::min.int(int a, int b) -> (bool)
207+
- prim::min.int_float(int a, float b) -> (bool)
208+
- prim::min.self_int(int[] self) -> (int)
209+
- prim::shape(Tensor a) -> (int[])

0 commit comments

Comments
 (0)