pytorch
644d6a09 - add overload name for aten::as_tensor (#39610)
Commit
4 years agoadd overload name for aten::as_tensor (#39610)
Summary:
Pull Request resolved: https://github.com/pytorch/pytorch/pull/39610
add overload name for aten::as_tensor
there are two aten::as_tensor
```
aten::as_tensor.float(float t, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::as_tensor.int(int t, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::as_tensor.bool(bool t, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::as_tensor(t[] data, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::as_tensor(Tensor(a) data, *, int? dtype=None, Device? device=None) -> (Tensor(b|a))
```
change one to aten::as_tensor.list
Test Plan:
verified no duplicated op name after this diff
This is the full list:
```
prim::TupleUnpack(Any tup) -> (...)
prim::unchecked_cast(t x) -> (t)
aten::IntImplicit(Tensor a) -> (int)
aten::FloatImplicit(Tensor a) -> (float)
aten::ScalarImplicit(Tensor a) -> (Scalar)
aten::Bool.Tensor(Tensor a) -> (bool)
aten::Bool.int(int a) -> (bool)
aten::Bool.float(float a) -> (bool)
aten::Float.Tensor(Tensor a) -> (float)
aten::Float.Scalar(Scalar a) -> (float)
aten::Float.int(int a) -> (float)
aten::Float.bool(bool a) -> (float)
aten::Float.str(str a) -> (float)
aten::format(str self, ...) -> (str)
prim::NumToTensor.Scalar(Scalar a) -> (Tensor)
prim::RaiseException(str msg) -> ()
aten::Size(int[] sizes) -> (int[])
aten::size(Tensor self) -> (int[])
prim::TupleIndex(Any tup, int i) -> (Any)
aten::ne.int_list(int[] a, int[] b) -> (bool)
prim::unchecked_unwrap_optional(t(a)? optional) -> (t(a))
prim::device(Tensor a) -> (Device)
prim::dtype(Tensor a) -> (int)
aten::__not__(bool self) -> (bool)
aten::__is__(t1 self, t2 obj) -> (bool)
aten::__isnot__(t1 self, t2 obj) -> (bool)
aten::element_size(Tensor self) -> (int)
aten::numel(Tensor self) -> (int)
aten::dim(Tensor self) -> (int)
aten::get_device(Tensor self) -> (int)
aten::storage_offset(Tensor self) -> (int)
aten::is_contiguous(Tensor self) -> (bool)
aten::select.t(t[](a) list, int idx) -> (t(*))
aten::__getitem__.t(t[](a) list, int idx) -> (t(*))
aten::append.t(t[](a!) self, t(c -> *) el) -> (t[](a!))
aten::reverse.t(t[](a!) self) -> ()
aten::extend.t(t[](a!) self, t[] other) -> ()
aten::copy.t(t[](a) self) -> (t[])
aten::_set_item.t(t[](a!) l, int idx, t(b -> *) el) -> (t[](a!))
aten::clear.t(t[](a!) self) -> ()
aten::Delete.t(t[](a!) self, int idx) -> ()
aten::insert.t(t[](a!) self, int idx, t(b -> *) el) -> ()
aten::pop.t(t[](a!) self, int idx=-1) -> (t(*))
aten::add.t(t[] a, t[] b) -> (t[])
aten::add_.t(t[](a!) self, t[] b) -> (t[])
aten::slice.t(t[] l, int start, int end=9223372036854775807, int step=1) -> (t[])
aten::list.t(t[] l) -> (t[])
aten::mul.left_t(t[] l, int n) -> (t[])
aten::mul.right_(int n, t[] l) -> (t[])
aten::mul_.t(t[](a!) l, int n) -> (t[](a!))
aten::len.t(t[] a) -> (int)
aten::eq.int_list(int[] a, int[] b) -> (bool)
prim::Uninitialized() -> (Any)
prim::Print(...) -> ()
aten::eq.int(int a, int b) -> (bool)
aten::eq.float(float a, float b) -> (bool)
aten::eq.int_float(int a, float b) -> (bool)
aten::eq.float_int(float a, int b) -> (bool)
aten::eq(Scalar a, Scalar b) -> (bool)
aten::eq.str(str a, str b) -> (bool)
aten::ne.int(int a, int b) -> (bool)
aten::ne.float(float a, float b) -> (bool)
aten::ne.int_float(int a, float b) -> (bool)
aten::ne.float_int(float a, int b) -> (bool)
aten::ne(Scalar a, Scalar b) -> (bool)
aten::ne.str(str a, str b) -> (bool)
aten::lt.int(int a, int b) -> (bool)
aten::lt.float(float a, float b) -> (bool)
aten::lt.int_float(int a, float b) -> (bool)
aten::lt.float_int(float a, int b) -> (bool)
aten::lt(Scalar a, Scalar b) -> (bool)
aten::lt.str(str a, str b) -> (bool)
aten::gt.int(int a, int b) -> (bool)
aten::gt.float(float a, float b) -> (bool)
aten::gt.int_float(int a, float b) -> (bool)
aten::gt.float_int(float a, int b) -> (bool)
aten::gt(Scalar a, Scalar b) -> (bool)
aten::gt.str(str a, str b) -> (bool)
aten::le.int(int a, int b) -> (bool)
aten::le.float(float a, float b) -> (bool)
aten::le.int_float(int a, float b) -> (bool)
aten::le.float_int(float a, int b) -> (bool)
aten::le(Scalar a, Scalar b) -> (bool)
aten::le.str(str a, str b) -> (bool)
aten::ge.int(int a, int b) -> (bool)
aten::ge.float(float a, float b) -> (bool)
aten::ge.int_float(int a, float b) -> (bool)
aten::ge.float_int(float a, int b) -> (bool)
aten::ge(Scalar a, Scalar b) -> (bool)
aten::ge.str(str a, str b) -> (bool)
aten::add.int(int a, int b) -> (int)
aten::add.float(float a, float b) -> (float)
aten::add.int_float(int a, float b) -> (float)
aten::add.float_int(float a, int b) -> (float)
aten::add(Scalar a, Scalar b) -> (Scalar)
aten::sub.int(int a, int b) -> (int)
aten::sub.float(float a, float b) -> (float)
aten::sub.int_float(int a, float b) -> (float)
aten::sub.float_int(float a, int b) -> (float)
aten::sub(Scalar a, Scalar b) -> (Scalar)
aten::mul.int(int a, int b) -> (int)
aten::mul.float(float a, float b) -> (float)
aten::mul.int_float(int a, float b) -> (float)
aten::mul.float_int(float a, int b) -> (float)
aten::mul(Scalar a, Scalar b) -> (Scalar)
aten::__and__(bool a, bool b) -> (bool)
aten::__or__(bool a, bool b) -> (bool)
aten::__xor__(bool a, bool b) -> (bool)
aten::remainder.int(int a, int b) -> (int)
aten::remainder.float(float a, float b) -> (float)
aten::remainder.int_float(int a, float b) -> (float)
aten::remainder.float_int(float a, int b) -> (float)
aten::remainder(Scalar a, Scalar b) -> (Scalar)
aten::div.int(int a, int b) -> (float)
aten::div.float(float a, float b) -> (float)
aten::div(Scalar a, Scalar b) -> (float)
aten::floordiv.int(int a, int b) -> (int)
aten::floordiv.float(float a, float b) -> (float)
aten::floordiv.int_float(int a, float b) -> (float)
aten::floordiv.float_int(float a, int b) -> (float)
aten::floordiv(Scalar a, Scalar b) -> (Scalar)
aten::pow.int(int a, int b) -> (float)
aten::pow.float(float a, float b) -> (float)
aten::pow.int_float(int a, float b) -> (float)
aten::pow.float_int(float a, int b) -> (float)
aten::pow(Scalar a, Scalar b) -> (float)
aten::pow.Scalar(Scalar a, Scalar b) -> (Scalar)
aten::pow.int_to_int(int a, int b) -> (int)
prim::min.int(int a, int b) -> (int)
prim::min.float(float a, float b) -> (float)
prim::min.int_float(int a, float b) -> (float)
prim::min.float_int(float a, int b) -> (float)
prim::min(Scalar a, Scalar b) -> (Scalar)
prim::max.int(int a, int b) -> (int)
prim::max.float(float a, float b) -> (float)
prim::max.int_float(int a, float b) -> (float)
prim::max.float_int(float a, int b) -> (float)
prim::max(Scalar a, Scalar b) -> (Scalar)
prim::type(Device self) -> (str)
aten::len.Tensor(Tensor t) -> (int)
aten::index.Tensor_hacked_twin(Tensor self, Tensor[] indices) -> (Tensor)
aten::_index_put_impl_.hacked_twin(Tensor(a!) self, Tensor[] indices, Tensor values, bool accumulate=False, bool unsafe=False) -> (Tensor(a!))
aten::index_put_.hacked_twin(Tensor(a!) self, Tensor[] indices, Tensor values, bool accumulate=False) -> (Tensor(a!))
aten::index_put.hacked_twin(Tensor self, Tensor[] indices, Tensor values, bool accumulate=False) -> (Tensor)
aten::to.prim_Device(Tensor(a) self, Device? device, int? dtype=None, bool non_blocking=False, bool copy=False) -> (Tensor(b|a))
aten::to.prim_dtype(Tensor(a) self, int? dtype=None, bool non_blocking=False, bool copy=False) -> (Tensor(b|a))
prim::is_cuda(Tensor a) -> (bool)
prim::data(Tensor(a) a) -> (Tensor(a))
prim::min.int_list(int[] l, int[] r) -> (int[])
prim::max.int_list(int[] l, int[] r) -> (int[])
prim::min.self_int(int[] self) -> (int)
prim::max.self_int(int[] self) -> (int)
prim::min.float_list(float[] l, float[] r) -> (float[])
prim::max.float_list(float[] l, float[] r) -> (float[])
prim::min.self_float(float[] self) -> (float)
prim::max.self_float(float[] self) -> (float)
prim::min.bool_list(bool[] l, bool[] r) -> (bool[])
prim::max.bool_list(bool[] l, bool[] r) -> (bool[])
prim::min.self_bool(bool[] self) -> (bool)
prim::max.self_bool(bool[] self) -> (bool)
aten::len.Dict_str(Dict(str, t) self) -> (int)
aten::keys.str(Dict(str, t) self) -> (str[](*))
aten::values.str(Dict(str, t) self) -> (t[](*))
aten::__getitem__.Dict_str(Dict(str, t) self, str key) -> (t(*))
aten::get.str(Dict(str, t) self, str key) -> (t(*)?)
aten::get.default_str(Dict(str, t) self, str key, t default_value) -> (t(*))
aten::setdefault.str(Dict(str, t)(a!) self, str(b -> *) key, t(c -> *) default_value) -> (t(*))
aten::Delete.Dict_str(Dict(str, t)(a!) self, str key) -> ()
aten::pop.Dict_str(Dict(str, t)(a!) self, str key) -> (t(*))
aten::pop.Dict_default_str(Dict(str, t)(a!) self, str key, t default_value) -> (t(*))
aten::popitem.str(Dict(str, t)(a!) self) -> ((str, t))
aten::clear.str(Dict(str, t)(a!) self) -> ()
aten::update.str(Dict(str, t)(a!) self, Dict(str, t)(a!) to_add) -> ()
aten::items.str(Dict(str, t) self) -> ((str, t)[])
aten::copy.Dict_str(Dict(str, t)(a) self) -> (Dict(str, t))
aten::__contains__.str(Dict(str, t) dict, str key) -> (bool)
aten::_set_item.str(Dict(str, t)(a!) l, str(b -> *) idx, t(c -> *) v) -> ()
aten::dict.str((str, tVal)[] inputs) -> (Dict(str, tVal))
aten::len.Dict_int(Dict(int, t) self) -> (int)
aten::keys.int(Dict(int, t) self) -> (int[](*))
aten::values.int(Dict(int, t) self) -> (t[](*))
aten::__getitem__.Dict_int(Dict(int, t) self, int key) -> (t(*))
aten::get.int(Dict(int, t) self, int key) -> (t(*)?)
aten::get.default_int(Dict(int, t) self, int key, t default_value) -> (t(*))
aten::setdefault.int(Dict(int, t)(a!) self, int(b -> *) key, t(c -> *) default_value) -> (t(*))
aten::Delete.Dict_int(Dict(int, t)(a!) self, int key) -> ()
aten::pop.Dict_int(Dict(int, t)(a!) self, int key) -> (t(*))
aten::pop.Dict_default_int(Dict(int, t)(a!) self, int key, t default_value) -> (t(*))
aten::popitem.int(Dict(int, t)(a!) self) -> ((int, t))
aten::clear.int(Dict(int, t)(a!) self) -> ()
aten::update.int(Dict(int, t)(a!) self, Dict(int, t)(a!) to_add) -> ()
aten::items.int(Dict(int, t) self) -> ((int, t)[])
aten::copy.Dict_int(Dict(int, t)(a) self) -> (Dict(int, t))
aten::__contains__.int(Dict(int, t) dict, int key) -> (bool)
aten::_set_item.int(Dict(int, t)(a!) l, int(b -> *) idx, t(c -> *) v) -> ()
aten::dict.int((int, tVal)[] inputs) -> (Dict(int, tVal))
aten::len.Dict_float(Dict(float, t) self) -> (int)
aten::keys.float(Dict(float, t) self) -> (float[](*))
aten::values.float(Dict(float, t) self) -> (t[](*))
aten::__getitem__.Dict_float(Dict(float, t) self, float key) -> (t(*))
aten::get.float(Dict(float, t) self, float key) -> (t(*)?)
aten::get.default_float(Dict(float, t) self, float key, t default_value) -> (t(*))
aten::setdefault.float(Dict(float, t)(a!) self, float(b -> *) key, t(c -> *) default_value) -> (t(*))
aten::Delete.Dict_float(Dict(float, t)(a!) self, float key) -> ()
aten::pop.Dict_float(Dict(float, t)(a!) self, float key) -> (t(*))
aten::pop.Dict_default_float(Dict(float, t)(a!) self, float key, t default_value) -> (t(*))
aten::popitem.float(Dict(float, t)(a!) self) -> ((float, t))
aten::clear.float(Dict(float, t)(a!) self) -> ()
aten::update.float(Dict(float, t)(a!) self, Dict(float, t)(a!) to_add) -> ()
aten::items.float(Dict(float, t) self) -> ((float, t)[])
aten::copy.Dict_float(Dict(float, t)(a) self) -> (Dict(float, t))
aten::__contains__.float(Dict(float, t) dict, float key) -> (bool)
aten::_set_item.float(Dict(float, t)(a!) l, float(b -> *) idx, t(c -> *) v) -> ()
aten::dict.float((float, tVal)[] inputs) -> (Dict(float, tVal))
aten::len.Dict_Tensor(Dict(Tensor, t) self) -> (int)
aten::keys.Tensor(Dict(Tensor, t) self) -> (Tensor[](*))
aten::values.Tensor(Dict(Tensor, t) self) -> (t[](*))
aten::__getitem__.Dict_Tensor(Dict(Tensor, t) self, Tensor key) -> (t(*))
aten::get.Tensor(Dict(Tensor, t) self, Tensor key) -> (t(*)?)
aten::get.default_Tensor(Dict(Tensor, t) self, Tensor key, t default_value) -> (t(*))
aten::setdefault.Tensor(Dict(Tensor, t)(a!) self, Tensor(b -> *) key, t(c -> *) default_value) -> (t(*))
aten::Delete.Dict_Tensor(Dict(Tensor, t)(a!) self, Tensor key) -> ()
aten::pop.Dict_Tensor(Dict(Tensor, t)(a!) self, Tensor key) -> (t(*))
aten::pop.Dict_default_Tensor(Dict(Tensor, t)(a!) self, Tensor key, t default_value) -> (t(*))
aten::popitem.Tensor(Dict(Tensor, t)(a!) self) -> ((Tensor, t))
aten::clear.Tensor(Dict(Tensor, t)(a!) self) -> ()
aten::update.Tensor(Dict(Tensor, t)(a!) self, Dict(Tensor, t)(a!) to_add) -> ()
aten::items.Tensor(Dict(Tensor, t) self) -> ((Tensor, t)[])
aten::copy.Dict_Tensor(Dict(Tensor, t)(a) self) -> (Dict(Tensor, t))
aten::__contains__.Tensor(Dict(Tensor, t) dict, Tensor key) -> (bool)
aten::_set_item.Tensor(Dict(Tensor, t)(a!) l, Tensor(b -> *) idx, t(c -> *) v) -> ()
aten::dict.Tensor((Tensor, tVal)[] inputs) -> (Dict(Tensor, tVal))
aten::split(Tensor self, int[] split_sizes, int dim=0) -> (Tensor[])
aten::tensor.float(float t, *, int? dtype=None, Device? device=None, bool requires_grad=False) -> (Tensor)
aten::as_tensor.float(float t, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::tensor.int(int t, *, int? dtype=None, Device? device=None, bool requires_grad=False) -> (Tensor)
aten::as_tensor.int(int t, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::tensor.bool(bool t, *, int? dtype=None, Device? device=None, bool requires_grad=False) -> (Tensor)
aten::as_tensor.bool(bool t, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::_infer_size(int[] a, int[] b) -> (int[])
aten::_no_grad_embedding_renorm_(Tensor weight, Tensor input, float max_norm, float norm_type) -> (Tensor)
aten::tensor(t[] data, *, int? dtype=None, Device? device=None, bool requires_grad=False) -> (Tensor)
aten::as_tensor(Tensor(a) data, *, int? dtype=None, Device? device=None) -> (Tensor(b|a))
aten::as_tensor.list(t[] data, *, int? dtype=None, Device? device=None) -> (Tensor)
aten::_pack_sequence(Tensor output, Tensor batch_sizes, Tensor? sorted_indices, Tensor? unsorted_indices) -> (Tensor, Tensor, Tensor?, Tensor?)
aten::_get_tracing_state() -> (bool)
aten::is_scripting() -> (bool)
aten::_no_grad_uniform_(Tensor(a!) tensor, float a, float b) -> (Tensor(a!))
aten::_no_grad_normal_(Tensor(a!) tensor, float mean, float std) -> (Tensor(a!))
aten::_no_grad_fill_(Tensor(a!) tensor, float val) -> (Tensor(a!))
aten::_no_grad_zero_(Tensor(a!) tensor) -> (Tensor(a!))
```
Reviewed By: iseeyuan
Differential Revision: D21915144
fbshipit-source-id: 35faac8db03931aebad6089488ef6ca691d230d9
Author
Committer
Parents
Loading