From bf24e57df99e0c8517f8c5ef89fbd6ef2c9b8dad Mon Sep 17 00:00:00 2001 From: sugarme Date: Wed, 11 Oct 2023 14:53:35 +1100 Subject: [PATCH] upgrade libtorch2.1.0 --- CHANGELOG.md | 2 + README.md | 23 +- gen/gen.ml | 6 +- gen/gen.ml.2.0 | 1444 + gen/pytorch/Declarations-v2.1.0.yaml | 202710 ++++++++++++++++++++++++ libtch/c-generated.go | 541 +- libtch/lib.go | 2 +- libtch/torch_api_generated.cpp.h | 551 +- libtch/torch_api_generated.h | 119 +- nn/optimizer_test.go | 4 +- setup-gotch.sh | 2 +- setup-libtorch.sh | 2 +- ts/must-tensor-generated.go | 552 +- ts/tensor-generated.go | 1417 +- 14 files changed, 206359 insertions(+), 1016 deletions(-) create mode 100644 gen/gen.ml.2.0 create mode 100644 gen/pytorch/Declarations-v2.1.0.yaml diff --git a/CHANGELOG.md b/CHANGELOG.md index 2a6cea5..4282461 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Nofix] - ctype `long` caused compiling error in MacOS as noted on [#44]. Not working on linux box. +# [0.9.0] +- Upgrade libtorch v2.1.0 # [0.8.0] - Upgrade libtorch v2.0.0 diff --git a/README.md b/README.md index 47d8eaa..2d6a179 100644 --- a/README.md +++ b/README.md @@ -3,10 +3,10 @@ ## Overview -`gotch` creates a thin wrapper to Pytorch C++ APIs (Libtorch) to make use of its already optimized C++ tensor APIs (>2500) and dynamic graph computation with CUDA support and provides idiomatic Go APIs for developing and implementing Deep Learning in Go. +`gotch` creates a thin wrapper to Pytorch C++ APIs (Libtorch) to make use of its already optimized C++ tensor APIs (3039) and dynamic graph computation with CUDA support and provides idiomatic Go APIs for developing and implementing Deep Learning in Go. **Some features are** -- [x] Comprehensive Pytorch tensor APIs +- [x] Comprehensive Pytorch tensor APIs (2525) - [x] Fully featured Pytorch dynamic graph computation - [x] JIT interface to run model trained/saved using PyTorch Python API - [x] Load pretrained Pytorch models and run inference @@ -16,16 +16,17 @@ `gotch` is in active development mode and may have API breaking changes. Feel free to pull request, report issues or discuss any concerns. All contributions are welcome. -`gotch` current version is **v0.8.0** +`gotch` current version is **v0.9.0** ## Dependencies -- **Libtorch** C++ v2.0.1 library of [Pytorch](https://pytorch.org/) +- **Libtorch** C++ v2.1.0 library of [Pytorch](https://pytorch.org/) +- Clang-17/Clang++-17 compilers ## Installation - Default CUDA version is `11.8` if CUDA is available otherwise using CPU version. -- Default Pytorch C++ API version is `2.0.1` +- Default Pytorch C++ API version is `2.1.0` **NOTE**: `libtorch` will be installed at **`/usr/local/lib`** @@ -34,7 +35,7 @@ #### Step 1: Setup libtorch (skip this step if a valid libtorch already installed in your machine!) ```bash - wget https://github.com/sugarme/gotch/releases/download/v0.8.0/setup-libtorch.sh + wget https://github.com/sugarme/gotch/releases/download/v0.9.0/setup-libtorch.sh chmod +x setup-libtorch.sh export CUDA_VER=cpu && bash setup-libtorch.sh ``` @@ -51,9 +52,9 @@ #### Step 2: Setup gotch ```bash - wget https://github.com/sugarme/gotch/releases/download/v0.8.0/setup-gotch.sh + wget https://github.com/sugarme/gotch/releases/download/v0.9.0/setup-gotch.sh chmod +x setup-gotch.sh - export CUDA_VER=cpu && export GOTCH_VER=v0.8.0 && bash setup-gotch.sh + export CUDA_VER=cpu && export GOTCH_VER=v0.9.0 && bash setup-gotch.sh ``` ### GPU @@ -67,7 +68,7 @@ #### Step 1: Setup libtorch (skip this step if a valid libtorch already installed in your machine!) ```bash - wget https://github.com/sugarme/gotch/releases/download/v0.8.0/setup-libtorch.sh + wget https://github.com/sugarme/gotch/releases/download/v0.9.0/setup-libtorch.sh chmod +x setup-libtorch.sh export CUDA_VER=11.8 && bash setup-libtorch.sh @@ -85,9 +86,9 @@ #### Step 2: Setup gotch ```bash - wget https://github.com/sugarme/gotch/releases/download/v0.8.0/setup-gotch.sh + wget https://github.com/sugarme/gotch/releases/download/v0.9.0/setup-gotch.sh chmod +x setup-gotch.sh - export CUDA_VER=11.8 && export GOTCH_VER=v0.8.0 && bash setup-gotch.sh + export CUDA_VER=11.8 && export GOTCH_VER=v0.9.0 && bash setup-gotch.sh ``` ## Examples diff --git a/gen/gen.ml b/gen/gen.ml index b5ed3ab..6a9424d 100644 --- a/gen/gen.ml +++ b/gen/gen.ml @@ -69,6 +69,10 @@ let excluded_functions = ; "unsafe_split_out" ; "unsafe_split_with_sizes_out" ; "_histogramdd_from_bin_cts" + ; "sym_numel" + ; "sym_size" + ; "sym_stride" + ; "sym_storage_offset" ] let no_tensor_options = @@ -1437,7 +1441,7 @@ let run ~yaml_filename ~cpp_filename ~ffi_filename ~must_wrapper_filename let () = - run ~yaml_filename:"gen/pytorch/Declarations-v2.0.0.yaml" + run ~yaml_filename:"gen/pytorch/Declarations-v2.1.0.yaml" ~cpp_filename:"libtch/torch_api_generated" ~ffi_filename:"libtch/c-generated.go" ~must_wrapper_filename:"ts/must-tensor-generated.go" diff --git a/gen/gen.ml.2.0 b/gen/gen.ml.2.0 new file mode 100644 index 0000000..b5ed3ab --- /dev/null +++ b/gen/gen.ml.2.0 @@ -0,0 +1,1444 @@ +(* Automatically generated C++ -> C -> Go bindings. + Input: Declarations-VERSION.yaml artifact generated when building Pytorch from source. + Run with: dune exec gen/gen.exe +*) +open Base +open Stdio + +let excluded_functions = + Set.of_list + (module String) + [ "multi_margin_loss" + ; "multi_margin_loss_out" + ; "log_softmax_backward_data" + ; "softmax_backward_data" + ; "clone" + ; "copy_" + ; "conv_transpose2d_backward_out" + ; "conv_transpose3d_backward_out" + ; "slow_conv_transpose2d_backward_out" + ; "slow_conv_transpose3d_backward_out" + ; "slow_conv3d_backward_out" + ; "normal" + ; "_cufft_set_plan_cache_max_size" + ; "_cufft_clear_plan_cache" + ; "backward" + ; "set_data" + ; "_amp_non_finite_check_and_unscale_" + ; "_amp_foreach_non_finite_check_and_unscale_" + ; "_cummin_helper" + ; "_cummax_helper" + ; "retain_grad" + ; "_validate_sparse_coo_tensor_args" + ; "_validate_sparse_csr_tensor_args" + ; "_backward" + ; "size" + ; "stride" + ; "histogram_out" + ; "histogram" + ; "_assert_async" + ; "gradient" + ; "linalg_vector_norm" + ; "linalg_vector_norm_out" + ; "linalg_matrix_norm" + ; "linalg_matrix_norm_out" + ; "_histogramdd_bin_edges" + ; "_histogramdd_bin_edges" + ; "_histogramdd_from_bin_cts" + ; "_linalg_check_errors" + ; "_index_copy_" + ; "_native_multi_head_self_attention" + ; "normal_out" + ; "bernoulli_out" + ; "nested_tensor" + ; "arange_out" + (* TODO: Fix `write cpp` so that it can seperate a non-return func *) + ; "_assert_tensor_metadata" + ; "_histogramdd_bin_edges_out" + ; "_validate_compressed_sparse_indices" + ; "_validate_sparse_bsc_tensor_args" + ; "_validate_sparse_bsr_tensor_args" + ; "_validate_sparse_compressed_tensor_args" + ; "_validate_sparse_csc_tensor_args" + ; "dequantize_out" + ; "lstm_mps_backward_out" + ; "quantize_per_tensor_out" + ; "split_copy_out" + ; "split_with_sizes_copy_out" + ; "unbind_copy_out" + ; "unsafe_split_out" + ; "unsafe_split_with_sizes_out" + ; "_histogramdd_from_bin_cts" + ] + +let no_tensor_options = + Set.of_list + (module String) + [ "zeros_like" + ; "empty_like" + ; "full_like" + ; "ones_like" + ; "rand_like" + ; "randint_like" + ; "randn_like" ] + +(* By default, scalar argument that have a default value are not available on + the Rust side, this is to preserve the Rust api simplicity assuming that + these scalars arguments are not often overriden. + Adding function name [foo] in [with_optional_scalar_args] results in having + explicit scalar arguments even if a default is present. *) +let with_optional_scalar_args = Set.of_list (module String) [ "arange"; "baddbmm" ] + + +(* + * let prefixed_functions = + * Set.of_list + * (module String) + * ["add"; "add_"; "div"; "div_"; "mul"; "mul_"; "sub"; "sub_"; "nll_loss"] + * *) +let excluded_prefixes = + ["_thnn_" + ; "_th_" + ; "thnn_" + ; "th_" + ; "_foreach" + ; "_amp_foreach" + ; "_nested_tensor" + ; "_fused_adam" + ] + +let excluded_suffixes = ["_forward"; "_forward_out"] + +let yaml_error yaml ~msg = + Printf.failwithf "%s, %s" msg (Yaml.to_string_exn yaml) () + +let extract_bool = function + | `Bool b -> b + | `String "true" -> true + | `String "false" -> false + | yaml -> yaml_error yaml ~msg:"expected bool" + +let extract_list = function + | `A l -> l + | yaml -> yaml_error yaml ~msg:"expected list" + +let extract_map = function + | `O map -> Map.of_alist_exn (module String) map + | yaml -> yaml_error yaml ~msg:"expected map" + +let extract_string = function + | `String s -> s + (* The yaml spec for torch uses n which is converted to a bool. *) + | `Bool b -> if b then "y" else "n" + | `Float f -> Float.to_string f + | yaml -> yaml_error yaml ~msg:"expected string" + +module Func = struct + type arg_type = + | Bool + | Int64 + | Int64Option + | Double + | DoubleOption + | Tensor + | TensorOption (* Tensor.t option *) + | IntList + | IntListOption + | DoubleList + | TensorOptList + | TensorList + | TensorOptions (* Tensor kind and device *) + | Scalar + | ScalarType + | ScalarTypeOption + | Device + | String + | Layout + | LayoutOption + + type arg = + { arg_name: string + ; arg_type: arg_type + ; default_value: string option + } + + (* `Func` type *) + type t = + { name: string + ; operator_name: string + ; overload_name: string + ; args: arg list (* ; returns: [`fixed of int | `dynamic] *) + ; returns: [`fixed of int | `dynamic | `bool | `int64_t | `double | `nothing] + ; (* number of tensors that are returned *) + kind: [`function_ | `method_] + } + + let arg_type_of_string str ~is_nullable = + match String.lowercase str with + | "bool" -> Some Bool + | "int64_t" -> Some (if is_nullable then Int64Option else Int64) + | "double" -> Some (if is_nullable then DoubleOption else Double) + | "at::tensor" -> Some (if is_nullable then TensorOption else Tensor) + | "at::tensoroptions" -> Some TensorOptions + | "at::intarrayref" -> Some (if is_nullable then IntListOption else IntList) + | "at::arrayref" -> Some DoubleList + | "const c10::list> &" -> Some TensorOptList + | "const at::itensorlistref &" | "at::tensorlist" -> Some TensorList + | "at::device" -> Some Device + | "const at::scalar &" | "at::scalar" -> Some Scalar + | "at::scalartype" -> if is_nullable then Some ScalarTypeOption else Some ScalarType + | "c10::string_view" -> Some String + | "at::layout" -> Some (if is_nullable then LayoutOption else Layout) + | _ -> None + + + let c_typed_args_list t = + List.map t.args ~f:(fun { arg_name; arg_type; _ } -> + match arg_type with + | IntList | IntListOption -> + Printf.sprintf "int64_t *%s_data, int %s_len" arg_name arg_name + | DoubleList -> Printf.sprintf "double *%s_data, int %s_len" arg_name arg_name + | TensorOptList | TensorList -> + Printf.sprintf "tensor *%s_data, int %s_len" arg_name arg_name + | TensorOptions -> Printf.sprintf "int %s_kind, int %s_device" arg_name arg_name + | String -> Printf.sprintf "char* %s_ptr, int %s_len" arg_name arg_name + | Int64Option -> Printf.sprintf "int64_t %s_v, uint8_t %s_null" arg_name arg_name + | DoubleOption -> Printf.sprintf "double %s_v, uint8_t %s_null" arg_name arg_name + | otherwise -> + let simple_type_cstring = + match otherwise with + | Bool -> "int" + | Int64 -> "int64_t" + | Double -> "double" + | Tensor -> "tensor" + | TensorOption -> "tensor" + | ScalarType -> "int" + | ScalarTypeOption -> "int" + | Device -> "int" + | Scalar -> "scalar" + | Layout | LayoutOption -> "int8_t" + | Int64Option + | DoubleOption + | String + | IntList + | IntListOption + | DoubleList + | TensorOptList + | TensorList + | TensorOptions -> assert false + in + Printf.sprintf "%s %s" simple_type_cstring arg_name) + |> String.concat ~sep:", " + + let c_args_list args = + List.map args ~f:(fun { arg_name; arg_type; _ } -> + match arg_type with + | Scalar | Tensor -> "*" ^ arg_name + | Layout -> Printf.sprintf "static_cast(%s)" arg_name + | LayoutOption -> + Printf.sprintf + "(%s == -1 ? c10::nullopt : \ + c10::optional(static_cast(%s)))" + arg_name + arg_name + | TensorOption -> Printf.sprintf "(%s ? *%s : torch::Tensor())" arg_name arg_name + | Bool -> "(bool)" ^ arg_name + | IntList -> Printf.sprintf "torch::IntArrayRef(%s_data, %s_len)" arg_name arg_name + | IntListOption -> + Printf.sprintf + "%s_data == nullptr ? c10::nullopt : \ + c10::optional(torch::IntArrayRef(%s_data, %s_len))" + arg_name + arg_name + arg_name + | DoubleList -> + Printf.sprintf "at::ArrayRef(%s_data, %s_len)" arg_name arg_name + | String -> Printf.sprintf "std::string(%s_ptr, %s_len)" arg_name arg_name + | TensorOptList -> + Printf.sprintf "of_carray_tensor_opt(%s_data, %s_len)" arg_name arg_name + | TensorList -> Printf.sprintf "of_carray_tensor(%s_data, %s_len)" arg_name arg_name + | TensorOptions -> + Printf.sprintf + "at::device(device_of_int(%s_device)).dtype(at::ScalarType(%s_kind))" + arg_name + arg_name + | Int64Option -> + Printf.sprintf + "%s_null ? c10::nullopt : c10::optional(%s_v)" + arg_name + arg_name + | DoubleOption -> + Printf.sprintf + "%s_null ? c10::nullopt : c10::optional(%s_v)" + arg_name + arg_name + | ScalarType -> Printf.sprintf "at::ScalarType(%s)" arg_name + | ScalarTypeOption -> + Printf.sprintf + "%s < 0 ? c10::nullopt : c10::optional(at::ScalarType(%s))" + arg_name + arg_name + | Device -> Printf.sprintf "device_of_int(%s)" arg_name + | _ -> arg_name) + |> String.concat ~sep:", " + + let c_call t = + match t.kind with + | `function_ -> Printf.sprintf "torch::%s(%s)" t.name (c_args_list t.args) + | `method_ -> + (match t.args with + | head :: tail -> + Printf.sprintf "%s->%s(%s)" head.arg_name t.name (c_args_list tail) + | [] -> + Printf.failwithf "Method calls should have at least one argument %s" t.name ()) + + (* + let replace_map = + Map.of_alist_exn + (module String) + [ ("t", "tr") + ; ("where", "where_") + ; ("view", "view_") + ; ("unsafe", "unsafe_") + ; ("to_device", "to_device_") ] + *) + + let operator_name t = + match String.lowercase t.operator_name with + | "scatter_reduce" -> + (* scatter_reduce is both an operator name and also obtained from the + scatter operator when using the reduce overload. *) + "_scatter_reduce" + | "scatter_reduce_" -> "_scatter_reduce_" + | other -> other + + let is_method t = + List.exists t.args ~f:(fun arg -> + match arg.arg_name with "self" -> true | _ -> false ) + + let go_name name = + let last_underscore name = Str.string_match (Str.regexp ".*_$") name 0 in + let words = Str.split (Str.regexp "_") name in + if last_underscore name then + let cap_words = List.map words ~f:(fun word -> String.capitalize word) in + String.concat ~sep:"" cap_words ^ "_" + else + let cap_words = List.map words ~f:(fun word -> String.capitalize word) in + String.concat ~sep:"" cap_words + + let go_variable name = + let goname = go_name name in + (* NOTE: Deal with Go namespace conflict *) + let safe_name = + match goname with + | "Var" -> "vari" + | "Unsafe" -> "unsafety" + | "Range" -> "rangeVals" + | _ -> goname + in + String.uncapitalize safe_name + + let c_go_args_list t = + List.map t.args ~f:(fun arg -> + let an = go_variable arg.arg_name in + let single_param = Printf.sprintf "%s %s" an in + match arg.arg_type with + | Bool -> single_param "int32" + | Layout | LayoutOption -> single_param "int8" + | Int64 -> single_param "int64" + | Double -> single_param "float64" + | Tensor -> single_param "Ctensor" + | TensorOption -> single_param "Ctensor" + | Scalar -> single_param "Cscalar" + | ScalarType | ScalarTypeOption -> single_param "int32" + | Device -> single_param "int32" + | String -> single_param "string" + | IntList | IntListOption -> Printf.sprintf "%sData []int64, %sLen int" an an + | DoubleList -> Printf.sprintf "%sData []float64, %sLen int" an an + | TensorOptList -> Printf.sprintf "%sData []Ctensor, %sLen int" an an + | TensorList -> Printf.sprintf "%sData []Ctensor, %sLen int" an an + | Int64Option -> Printf.sprintf "%sVal int64, %sNull int" an an + | DoubleOption -> Printf.sprintf "%sVal float64, %sNull int" an an + | TensorOptions -> Printf.sprintf "%sKind int32, %sDevice int32" an an + ) + |> String.concat ~sep:", " + + let c_go_args_list_notype t = + List.map t.args ~f:(fun arg -> + let an = go_variable arg.arg_name in + let an = match an with "var" -> "vari" | _ -> an in + let single_param = Printf.sprintf "%s %s" an in + match arg.arg_type with + | Bool -> Printf.sprintf "c%s" an + | Int64 -> Printf.sprintf "c%s" an + | Double -> Printf.sprintf "c%s" an + | Tensor -> Printf.sprintf "%s" an + | TensorOption -> Printf.sprintf "%s" an + | Layout | LayoutOption -> Printf.sprintf "c%s" an + | Scalar -> single_param "" + | ScalarType | ScalarTypeOption -> Printf.sprintf "c%s" an + | Device -> Printf.sprintf "c%s" an + | String -> Printf.sprintf "c%s, c%sLen" an an + | IntList | IntListOption -> Printf.sprintf "c%sDataPtr, c%sLen" an an + | DoubleList -> Printf.sprintf "c%sDataPtr, c%sLen" an an + | TensorOptList -> Printf.sprintf "c%sDataPtr, c%sLen" an an + | TensorList -> Printf.sprintf "c%sDataPtr, c%sLen" an an + | Int64Option -> Printf.sprintf "c%sVal, c%sNull" an an + | DoubleOption -> Printf.sprintf "c%sVal, c%sNull" an an + | TensorOptions -> Printf.sprintf "c%sKind, c%sDevice" an an ) + |> String.concat ~sep:", " + + (* TODO: convert Go pointer to C pointer *) + let c_go_args_list_body t = + List.map t.args ~f:(fun arg -> + let an = go_variable arg.arg_name in + (* let single_param = Printf.sprintf "%s %s" an in *) + match arg.arg_type with + | Bool -> + Printf.sprintf "\nc%s := *(*C.int)(unsafe.Pointer(&%s))" an an + | Int64 -> + Printf.sprintf "\nc%s := *(*C.int64_t)(unsafe.Pointer(&%s))" an an + | Double -> + Printf.sprintf "\nc%s := *(*C.double)(unsafe.Pointer(&%s))" an an + | Tensor -> "" + | TensorOption -> "" + | Layout | LayoutOption -> + Printf.sprintf "\nc%s := *(*C.int8_t)(unsafe.Pointer(&%s))" an an + | Scalar -> "" + | ScalarType | ScalarTypeOption -> + Printf.sprintf "\nc%s := *(*C.int)(unsafe.Pointer(&%s))" an an + | Device -> + Printf.sprintf "\nc%s := *(*C.int)(unsafe.Pointer(&%s))" an an + | String -> + Printf.sprintf + "\n\ + c%s := C.CString(%s)\n\ + %sLen := len(%s)\n\ + c%sLen := *(*C.int)(unsafe.Pointer(&%sLen))" + an an an an an an + | IntList | IntListOption -> + Printf.sprintf + "\n\ + c%sDataPtr := (*C.int64_t)(unsafe.Pointer(&%sData[0]))\n\ + c%sLen := *(*C.int)(unsafe.Pointer(&%sLen))" + an an an an + | DoubleList -> + Printf.sprintf + "\n\ + c%sDataPtr := (*C.double)(unsafe.Pointer(&%sData[0]))\n\ + c%sLen := *(*C.int)(unsafe.Pointer(&%sLen))" + an an an an + | TensorOptList -> + Printf.sprintf + "\n\ + c%sDataPtr := (*Ctensor)(unsafe.Pointer(&%sData[0]))\n\ + c%sLen := *(*C.int)(unsafe.Pointer(&%sLen))" + an an an an + | TensorList -> + Printf.sprintf + "\n\ + c%sDataPtr := (*Ctensor)(unsafe.Pointer(&%sData[0]))\n\ + c%sLen := *(*C.int)(unsafe.Pointer(&%sLen))" + an an an an + | Int64Option -> + Printf.sprintf + "\n\ + c%sVal := *(*C.int64_t)(unsafe.Pointer(&%sVal))\n\ + c%sNull := *(*C.uint8_t)(unsafe.Pointer(&%sNull))" + an an an an + | DoubleOption -> + Printf.sprintf + "\n\ + c%sVal := *(*C.double)(unsafe.Pointer(&%sVal))\n\ + c%sNull := *(*C.uint8_t)(unsafe.Pointer(&%sNull))" + an an an an + | TensorOptions -> + Printf.sprintf + "\n\ + c%sKind := *(*C.int)(unsafe.Pointer(&%sKind))\n\ + c%sDevice := *(*C.int)(unsafe.Pointer(&%sDevice))" + an an an an ) + |> String.concat ~sep:"" + + let self_name = "self" + + let self_tensor arg = + match arg.arg_type with + | Tensor -> String.( = ) arg.arg_name self_name + | _ -> false + + (* + * let type_parameters t = + * let needs_scalar_parameter = + * List.exists t.args ~f:(fun arg -> + * match arg.arg_type with Scalar -> true | _ -> false ) + * in + * let needs_type_parameter = + * List.exists t.args ~f:(fun arg -> + * match arg.arg_type with + * | TensorList | TensorOption -> true + * | _ -> false ) + * in + * if needs_type_parameter && needs_scalar_parameter then "Tensor, Scalar" + * else if needs_type_parameter then "Tensor" + * else if needs_scalar_parameter then "Scalar" + * else "" + * *) + + (* + * let go_args_list t = + * (* https://ocaml.janestreet.com/ocaml-core/latest/doc/base/Base/List/#val-partition_tf *) + * (* TODO. implement special cases - TensorOptions, ... *) + * match List.partition_tf t.args ~f:self_tensor with _, args_list -> + * args_list + * *) + + let is_inplace t = + match Str.string_match (Str.regexp ".*_$") t.name 0 with + | true -> true + | _ -> false + + let go_typed_args_list t = + let to_string args = + let args_list = + List.map args ~f:(fun arg -> + let go_arg_type = + match arg.arg_type with + | Bool -> "bool" + | Layout | LayoutOption -> "Layout" + | Int64 -> "int64" + | Double -> "float64" + | Tensor -> "*Tensor" + | TensorOption -> "*Tensor" + | IntList | IntListOption -> "[]int64" + | DoubleList -> "[]float64" + | TensorOptList -> "[]*Tensor" + | TensorList -> "[]*Tensor" + | String -> "string" + (* TODO. Struct{Kind gotch.DType Device gotch.Device} *) + (* E.g. `type KindDevice struct{}` *) + | TensorOptions -> "gotch.KindDevice" + | Scalar -> "*Scalar" + | ScalarType | ScalarTypeOption -> "gotch.DType" + | Int64Option -> "[]int64" + | DoubleOption -> "[]float64" + | Device -> "gotch.Device" + in + match arg.arg_type with + | TensorOptions -> + Printf.sprintf "%sKind gotch.DType, %sDevice gotch.Device" + (go_variable arg.arg_name) (go_variable arg.arg_name) + | _ -> Printf.sprintf "%s %s" (go_variable arg.arg_name) go_arg_type + ) + in + if is_method t && not (is_inplace t) then + args_list @ ["del bool"] |> String.concat ~sep:", " + else args_list |> String.concat ~sep:", " + in + (* let self_arg = "self Tensor" in *) + match List.partition_tf t.args ~f:self_tensor with _, args_list -> + Printf.sprintf "%s" (to_string args_list) + + let go_notype_args_list t = + let to_string args = + let args_list = + List.map args ~f:(fun arg -> + match arg.arg_type with + | TensorOptions -> + Printf.sprintf "%sKind, %sDevice" (go_variable arg.arg_name) + (go_variable arg.arg_name) + | _ -> Printf.sprintf "%s" (go_variable arg.arg_name) ) + in + if is_method t && not (is_inplace t) then + args_list @ ["del"] |> String.concat ~sep:", " + else args_list |> String.concat ~sep:", " + in + match List.partition_tf t.args ~f:self_tensor with _, args_list -> + Printf.sprintf "%s" (to_string args_list) + + let go_return_type t ~fallible = + (* printf "t name: %s\n" t.name ; *) + let returns = + match t.returns with + | `nothing -> None + | `fixed 1 -> Some "retVal *Tensor" + | `fixed v -> + List.init v ~f:(fun i -> Printf.sprintf "retVal%d *Tensor" i) + |> String.concat ~sep:", " + |> Printf.sprintf "%s" + |> Option.some + | `dynamic -> Some "retVal []*Tensor" + | `bool -> Some "retVal bool" + | `int64_t -> Some "retVal int64" + | `double -> Some "retVal float64" + in + match returns with + | None -> if fallible then Printf.sprintf "err error" else Printf.sprintf "" + | Some returns -> + if is_inplace t then + if fallible then Printf.sprintf "err error" else Printf.sprintf "" + else if fallible then Printf.sprintf "%s, err error" returns + else Printf.sprintf "%s" returns + + let go_return_notype t ~fallible = + let returns = + match t.returns with + | `nothing -> None + | `fixed 1 -> Some "retVal" + | `fixed v -> + List.init v ~f:(fun i -> Printf.sprintf "retVal%d" i) + |> String.concat ~sep:", " + |> Printf.sprintf "%s" + |> Option.some + | `dynamic -> Some "retVal" + | `bool -> Some "retVal" + | `int64_t -> Some "retVal" + | `double -> Some "retVal" + in + match returns with + | None -> if fallible then Printf.sprintf "err" else Printf.sprintf "" + | Some returns -> + if is_inplace t then + if fallible then Printf.sprintf "err" else Printf.sprintf "" + else if fallible then Printf.sprintf "%s, err" returns + else Printf.sprintf "%s" returns + + let go_binding_args t = + List.map t.args ~f:(fun arg -> + let name = go_variable arg.arg_name in + match arg.arg_type with + | Tensor -> + if String.( = ) name "self" then "ts.ctensor" + else Printf.sprintf "%s.ctensor" name + | Scalar -> Printf.sprintf "%s.cscalar" name + | Bool -> Printf.sprintf "c%s" name + | ScalarType | ScalarTypeOption -> Printf.sprintf "%s.CInt()" name + | Device -> Printf.sprintf "%s.CInt()" name + | TensorOptions -> + Printf.sprintf "%sKind.CInt(), %sDevice.CInt()" name name + | String -> Printf.sprintf "%s" name + | IntList -> Printf.sprintf "%s, %sLen" name name + | IntListOption -> Printf.sprintf "%s, %sLen" name name + | DoubleList -> Printf.sprintf "%s, %sLen" name name + | TensorList -> Printf.sprintf "c%s, len(c%s)" name name + | TensorOptList -> Printf.sprintf "c%s, len(c%s)" name name + | Int64Option -> Printf.sprintf "c%sVal, c%sNull" name name + | DoubleOption -> Printf.sprintf "c%sVal, c%sNull" name name + | TensorOption -> Printf.sprintf "%s.ctensor" name + | Layout -> Printf.sprintf "int8(%s)" name + | LayoutOption -> Printf.sprintf "int8(%s)" name + | _ -> name ) + |> String.concat ~sep:", " + + let go_binding_body t = + List.map t.args ~f:(fun arg -> + let an = go_variable arg.arg_name in + match arg.arg_type with + | Bool -> + Printf.sprintf "c%s := int32(0)\n if %s { c%s = int32(1) }\n" an an + an + | Int64 -> "" + | Double -> "" + | Tensor -> "" + | TensorOption -> "" + | Scalar -> "" + | ScalarType | ScalarTypeOption -> "" + | Device -> "" + | String -> "" + | IntList | IntListOption -> Printf.sprintf "%sLen := len(%s)\n" an an + | DoubleList -> Printf.sprintf "%sLen := len(%s)\n" an an + | Int64Option -> + Printf.sprintf + "var c%sVal int64 = 0\n\ + \ var c%sNull int = 1\n\ + \ if len(%s) > 0 {\n\ + \ c%sVal = %s[0]\n\ + \ c%sNull = 0\n\ + \ }\n" + an an an an an an + | DoubleOption -> + Printf.sprintf + "var c%sVal float64 = 0.0\n\ + \ var c%sNull int = 1\n\ + \ if len(%s) > 0 {\n\ + \ c%sVal = %s[0]\n\ + \ c%sNull = 0\n\ + \ }\n" + an an an an an an + | TensorOptList -> + Printf.sprintf + "var c%s []lib.Ctensor\n\ + \ for _, t := range %s {c%s = append(c%s, t.ctensor)}\n" + an an an an + | TensorList -> + Printf.sprintf + "var c%s []lib.Ctensor\n\ + \ for _, t := range %s {c%s = append(c%s, t.ctensor)}\n" + an an an an + | Layout | LayoutOption -> "" + | TensorOptions -> "" ) + |> String.concat ~sep:"" +end + +exception Not_a_simple_arg + +let read_yaml filename = + let funcs = + (* Split the file to avoid Yaml.of_string_exn segfaulting. *) + In_channel.with_file filename ~f:In_channel.input_lines + |> List.group ~break:(fun _ l -> String.length l > 0 && Char.( = ) l.[0] '-') + |> List.concat_map ~f:(fun lines -> + Yaml.of_string_exn (String.concat lines ~sep:"\n") |> extract_list) + in + printf "Read %s, got %d functions.\n%!" filename (List.length funcs); + List.filter_map funcs ~f:(fun yaml -> + let map = extract_map yaml in + let name = Map.find_exn map "name" |> extract_string in + let operator_name = Map.find_exn map "operator_name" |> extract_string in + let overload_name = Map.find_exn map "overload_name" |> extract_string in + let deprecated = Map.find_exn map "deprecated" |> extract_bool in + let method_of = + Map.find_exn map "method_of" |> extract_list |> List.map ~f:extract_string + in + let arguments = Map.find_exn map "arguments" |> extract_list in + let returns = + let is_tensor returns = + let returns = extract_map returns in + let return_type = Map.find_exn returns "dynamic_type" |> extract_string in + String.( = ) return_type "at::Tensor" + in + let returns = Map.find_exn map "returns" |> extract_list in + if List.is_empty returns + then Some `nothing + else if List.for_all returns ~f:is_tensor + then Some (`fixed (List.length returns)) + else ( + match returns with + | [ returns ] -> + let return_type = + Map.find_exn (extract_map returns) "dynamic_type" |> extract_string + in + (match return_type with + | "bool" -> Some `bool + | "int64_t" -> Some `int64_t + | "double" -> Some `double + | "at::TensorList" | "dynamic_type: const c10::List> &" + -> Some `dynamic + | _ -> None) + | [] | _ :: _ :: _ -> None) + in + let kind = + if List.exists method_of ~f:(String.( = ) "namespace") + then Some `function_ + else if List.exists method_of ~f:(String.( = ) "Tensor") + then Some `method_ + else None + in + if (not deprecated) + && (not + (List.exists excluded_prefixes ~f:(fun prefix -> + String.is_prefix name ~prefix))) + && (not + (List.exists excluded_suffixes ~f:(fun suffix -> + String.is_suffix name ~suffix))) + && not (Set.mem excluded_functions name) + then + Option.both returns kind + |> Option.bind ~f:(fun (returns, kind) -> + try + let args ~with_optional_scalar_args = + List.filter_map arguments ~f:(fun arg -> + let arg = extract_map arg in + let arg_name = Map.find_exn arg "name" |> extract_string in + let arg_type = Map.find_exn arg "dynamic_type" |> extract_string in + let is_nullable = + Map.find arg "is_nullable" + |> Option.value_map ~default:false ~f:extract_bool + in + let default_value = + Map.find arg "default" |> Option.map ~f:extract_string + in + match Func.arg_type_of_string arg_type ~is_nullable with + | Some Scalar when Option.is_some default_value && not is_nullable -> + if with_optional_scalar_args + then Some { Func.arg_name; arg_type = Scalar; default_value } + else None + | Some TensorOptions + when Option.is_some default_value && Set.mem no_tensor_options name -> + None + | Some arg_type -> + let arg_name = + match arg_name, arg_type with + | "self", Scalar -> "self_scalar" + | _, _ -> arg_name + in + Some { Func.arg_name; arg_type; default_value } + | None -> + if Option.is_some default_value then None else raise Not_a_simple_arg) + in + let args = + args ~with_optional_scalar_args:(Set.mem with_optional_scalar_args name) + in + Some [ { Func.name; operator_name; overload_name; args; returns; kind } ] + with + | Not_a_simple_arg -> None) + else None) + +let p out_channel s = + Printf.ksprintf + (fun line -> + Out_channel.output_string out_channel line ; + Out_channel.output_char out_channel '\n' ) + s + +let print_inline out_channel s = + Printf.ksprintf (fun msg -> Out_channel.output_string out_channel msg) s + +let write_cpp funcs filename = + Out_channel.with_file (filename ^ ".cpp.h") ~f:(fun out_cpp -> + Out_channel.with_file (filename ^ ".h") ~f:(fun out_h -> + let pc s = p out_cpp s in + let ph s = p out_h s in + pc "// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND!"; + pc ""; + ph "// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND!"; + ph ""; + Map.iteri funcs ~f:(fun ~key:exported_name ~data:func -> + let c_typed_args_list = Func.c_typed_args_list func in + match func.returns with + | `nothing -> + pc "void atg_%s(%s) {" exported_name c_typed_args_list; + pc " PROTECT("; + pc " %s;" (Func.c_call func); + pc " )"; + pc "}"; + pc ""; + ph "void atg_%s(%s);" exported_name c_typed_args_list + | `fixed ntensors -> + pc "void atg_%s(tensor *out__, %s) {" exported_name c_typed_args_list; + pc " PROTECT("; + pc " auto outputs__ = %s;" (Func.c_call func); + if ntensors = 1 + then pc " out__[0] = new torch::Tensor(outputs__);" + else + for i = 0 to ntensors - 1 do + pc " out__[%d] = new torch::Tensor(std::get<%d>(outputs__));" i i + done; + pc " )"; + pc "}"; + pc ""; + ph "void atg_%s(tensor *, %s);" exported_name c_typed_args_list + | `dynamic -> + pc "tensor *atg_%s(%s) {" exported_name c_typed_args_list; + pc " PROTECT("; + pc " auto outputs__ = %s;" (Func.c_call func); + (* the returned type is a C++ vector of tensors *) + pc " int sz = outputs__.size();"; + pc + " torch::Tensor **out__ = (torch::Tensor**)malloc((sz + 1) * \ + sizeof(torch::Tensor*));"; + pc " for (int i = 0; i < sz; ++i)"; + pc " out__[i] = new torch::Tensor(outputs__[i]);"; + pc " out__[sz] = nullptr;"; + pc " return out__;"; + pc " )"; + pc " return nullptr;"; + pc "}"; + pc ""; + ph "tensor *atg_%s(%s);" exported_name c_typed_args_list + | (`bool | `int64_t | `double) as returns -> + let c_type = + match returns with + | `bool -> "int" + | `int64_t -> "int64_t" + | `double -> "double" + in + pc "%s atg_%s(%s) {" c_type exported_name c_typed_args_list; + pc " PROTECT("; + pc " return %s;" (Func.c_call func); + pc " )"; + pc " return 0;"; + pc "}"; + pc ""; + ph "%s atg_%s(%s);" c_type exported_name c_typed_args_list))) + +let write_wrapper funcs filename = + Out_channel.with_file filename ~f:(fun out_ml -> + let pm s = print_inline out_ml s in + pm "package ts" ; + pm "\n\n" ; + pm "// NOTE. THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND!" ; + pm "\n\n" ; + pm "// #include \"stdlib.h\"\n" ; + pm "import \"C\"" ; + pm "" ; + pm "\n\n" ; + pm "import(\n" ; + pm " \"unsafe\"\n" ; + pm " \"fmt\"\n" ; + pm "\n" ; + pm " \"github.com/sugarme/gotch\"\n" ; + pm " lib \"github.com/sugarme/gotch/libtch\"\n" ; + pm ")" ; + pm "\n\n" ; + Map.iteri funcs ~f:(fun ~key:exported_name ~data: (func : Func.t) -> + let is_method = Func.is_method func in + let is_inplace = Func.is_inplace func in + (* NOTE. `torch.__PATTERN` *) + let prefix_2underscore exported_name = + Str.string_match (Str.regexp "^__") exported_name 0 + in + (* NOTE. `torch._PATTERN` *) + let prefix_1underscore exported_name = + Str.string_match (Str.regexp "^_") exported_name 0 + in + (* NOTE. `torch.PATTERN_1` *) + let suffix_1 exported_name = + Str.string_match (Str.regexp ".*_1$") exported_name 0 + in + let gofunc_name = + if prefix_2underscore exported_name then + "__" ^ Func.go_name exported_name + else if prefix_1underscore exported_name then + "_" ^ Func.go_name exported_name + else if suffix_1 exported_name then + Func.go_name exported_name ^ "_" + else Func.go_name exported_name + in + let cfunc_name = "lib.Atg" ^ gofunc_name in + let go_args_list = Func.go_typed_args_list func in + (* NOTE. temporarily excluding these functions as not implemented at FFI *) + (* TODO. implement multiple tensors return function []Tensor *) + let excluded_funcs = + [ "Chunk" + ; "AlignTensors" + ; "BroadcastTensors" + ; "Meshgrid" + ; "MeshgridIndexing" + ; "_ToCpu" + ; "NonzeroNumpy" + ; "Split" + ; "SplitWithSizes" + ; "Unbind" + ; "Where" + ; "Atleast1d1" + ; "Atleast2d1" + ; "Atleast3d1" + ; "Dequantize1" + ; "QuantizePerTensor1" + ; "UnsafeChunk" + ; "UnsafeSplit" + ; "UnsafeSplitWithSizes" + ; "AlignTensors" + ; "UnflattenDenseTensors" + ; "TensorSplit" + ; "TensorSplitIndices" + ; "TensorSplitTensorIndicesOrSections" + ; "QuantizePerTensorTensors" + ; "Dsplit" + ; "DsplitArray" + ; "Hsplit" + ; "HsplitArray" + ; "Vsplit" + ; "VsplitArray" + ; "DequantizeTensors" + ; "Atleast1dSequence" + ; "Atleast2dSequence" + ; "Atleast3dSequence" + ; "Index" + ; "IndexPut" + ; "IndexPut_" + ; "_IndexPutImpl_" ] + in + if + List.exists excluded_funcs ~f:(fun name -> + String.( = ) name gofunc_name ) + then pm "" + else + match func.returns with + | `nothing -> pm ""; (* TODO. implement manually*) + | `dynamic -> pm ""; (* TODO. implement manually*) + | `fixed 1 -> + pm "\n" ; + + pm "// func.returns = `fixed 1`: \n"; + pm "// --------------------------\n"; + pm "\n" ; + if is_method then pm "func(ts *Tensor) %s(" gofunc_name + else pm "func %s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:true) ; + if is_method && not is_inplace then + pm " if del { defer ts.MustDrop() }\n" ; + pm " ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0)))\n" ; + pm " \n" ; + pm " %s" (Func.go_binding_body func) ; + pm " %s(ptr, %s)\n" cfunc_name (Func.go_binding_args func) ; + pm " if err = TorchErr(); err != nil {\n" ; + pm " err = fmt.Errorf(\"%s() failed: %%w\", err)\n" gofunc_name; + pm " return %s\n" + (Func.go_return_notype func ~fallible:true) ; + pm " }\n" ; + (* NOTE. if in_place method, no retVal return *) + if not (Func.is_inplace func) then + pm " retVal = newTensor(*ptr, \"%s\")\n" gofunc_name + else pm " ts.ctensor = *ptr\n" ; + pm " \n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:true) ; + pm "} \n" + + + | `fixed ntensors -> + pm "\n" ; + + pm "// func.returns = `fixed ntensors`: \n"; + pm "// ---------------------------------\n"; + + if is_method then pm "func(ts *Tensor) %s(" gofunc_name + else pm "func %s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:true) ; + if is_method && not is_inplace then + pm " if del { defer ts.MustDrop() }\n" ; + for i = 0 to ntensors - 1 do + (* pc " out__[%d] = new torch::Tensor(std::get<%d>(outputs__));" i i *) + if i = 0 then + pm + " ctensorPtr0 := \ + (*lib.Ctensor)(unsafe.Pointer(C.malloc(0)))\n" + else + pm + " ctensorPtr%d := \ + (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr%d)) \ + + unsafe.Sizeof(ctensorPtr0)))\n" + i (i - 1) + done ; + pm " \n" ; + pm " %s" (Func.go_binding_body func) ; + pm " %s(ctensorPtr0, %s)\n" cfunc_name + (Func.go_binding_args func) ; + pm " if err = TorchErr(); err != nil {\n" ; + pm " err = fmt.Errorf(\"%s() failed: %%w\", err)\n" gofunc_name; + pm " return %s\n" + (Func.go_return_notype func ~fallible:true) ; + pm " }\n" ; + (* NOTE. if in_place method, no retVal return *) + if not (Func.is_inplace func) then + for i = 0 to ntensors - 1 do + pm " retVal%d = newTensor(*ctensorPtr%d, \"%s_%d\")\n" i i gofunc_name i + done + else pm " ts.ctensor = *ptr\n" ; + pm " \n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:true) ; + pm "} \n" + | `bool -> + pm "\n" ; + + pm "// func.returns = `bool`: \n"; + pm "// --------------------------\n"; + + if is_method then pm "func(ts *Tensor) %s(" gofunc_name + else pm "func %s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:true) ; + if is_method && not is_inplace then + pm " if del { defer ts.MustDrop() }\n" ; + pm " \n" ; + pm " %s" (Func.go_binding_body func) ; + pm " retVal = %s(%s)\n" cfunc_name (Func.go_binding_args func) ; + pm " if err = TorchErr(); err != nil {\n" ; + pm " err = fmt.Errorf(\"%s() failed: %%w\", err)\n" gofunc_name; + pm " return %s\n" + (Func.go_return_notype func ~fallible:true) ; + pm " }\n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:true) ; + pm "} \n" + | `int64_t -> + pm "\n" ; + + pm "// func.returns = `int64`: \n"; + pm "// --------------------------\n"; + + if is_method then pm "func(ts *Tensor) %s(" gofunc_name + else pm "func %s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:true) ; + if is_method && not is_inplace then + pm " if del { defer ts.MustDrop() }\n" ; + pm " \n" ; + pm " %s" (Func.go_binding_body func) ; + pm " retVal = %s(%s)\n" cfunc_name (Func.go_binding_args func) ; + pm " if err = TorchErr(); err != nil {\n" ; + pm " err = fmt.Errorf(\"%s() failed: %%w\", err)\n" gofunc_name; + pm " return %s\n" + (Func.go_return_notype func ~fallible:true) ; + pm " }\n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:true) ; + pm "} \n" + | `double -> + + pm "// func.returns = `double `: \n"; + pm "// --------------------------\n"; + + pm "\n" ; + if is_method then pm "func(ts *Tensor) %s(" gofunc_name + else pm "func %s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:true) ; + if is_method && not is_inplace then + pm "if del { defer ts.MustDrop() }\n" ; + pm " \n" ; + pm " %s" (Func.go_binding_body func) ; + pm " retVal = %s(%s)\n" cfunc_name (Func.go_binding_args func) ; + pm " if err = TorchErr(); err != nil {\n" ; + pm " err = fmt.Errorf(\"%s() failed: %%w\", err)\n" gofunc_name; + pm " return %s\n" + (Func.go_return_notype func ~fallible:true) ; + pm " }\n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:true) ; + pm "} \n" ) ; + pm "// End of implementing Tensor ================================= \n" + ) + +let write_must_wrapper funcs filename = + Out_channel.with_file filename ~f:(fun out_ml -> + let pm s = print_inline out_ml s in + pm "package ts" ; + pm "\n\n" ; + pm "// NOTE. THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND!" ; + pm "\n\n" ; + pm "import(\n" ; + pm " \"log\"\n" ; + pm "\n" ; + pm " \"github.com/sugarme/gotch\"\n" ; + pm ")" ; + pm "\n\n" ; + Map.iteri funcs ~f:(fun ~key:exported_name ~data:(func: Func.t) -> + let is_method = Func.is_method func in + (* NOTE. `torch.__PATTERN` *) + let prefix_2underscore exported_name = + Str.string_match (Str.regexp "^__") exported_name 0 + in + (* NOTE. `torch._PATTERN` *) + let prefix_1underscore exported_name = + Str.string_match (Str.regexp "^_") exported_name 0 + in + (* NOTE. `torch.PATTERN_1` *) + let suffix_1 exported_name = + Str.string_match (Str.regexp ".*_1$") exported_name 0 + in + let gofunc_name = + if prefix_2underscore exported_name then + "__" ^ Func.go_name exported_name + else if prefix_1underscore exported_name then + "_" ^ Func.go_name exported_name + else if suffix_1 exported_name then + Func.go_name exported_name ^ "_" + else Func.go_name exported_name + in + let go_args_list = Func.go_typed_args_list func in + let go_args_list_notype = Func.go_notype_args_list func in + (* NOTE. temporarily excluding these functions as not implemented at FFI *) + let excluded_funcs = + [ "Chunk" + ; "AlignTensors" + ; "BroadcastTensors" + ; "Meshgrid" + ; "MeshgridIndexing" + ; "_ToCpu" + ; "NonzeroNumpy" + ; "Split" + ; "SplitWithSizes" + ; "Unbind" + ; "Where" + ; "Atleast1d1" + ; "Atleast2d1" + ; "Atleast3d1" + ; "Dequantize1" + ; "QuantizePerTensor1" + ; "UnsafeChunk" + ; "UnsafeSplit" + ; "UnsafeSplitWithSizes" + ; "AlignTensors" + ; "UnflattenDenseTensors" + ; "TensorSplit" + ; "TensorSplitIndices" + ; "TensorSplitTensorIndicesOrSections" + ; "QuantizePerTensorTensors" + ; "Dsplit" + ; "DsplitArray" + ; "Hsplit" + ; "HsplitArray" + ; "Vsplit" + ; "VsplitArray" + ; "DequantizeTensors" + ; "Atleast1dSequence" + ; "Atleast2dSequence" + ; "Atleast3dSequence" + ; "Index" + ; "IndexPut" + ; "IndexPut_" + ; "_IndexPutImpl_" ] + in + if + List.exists excluded_funcs ~f:(fun name -> + String.( = ) name gofunc_name ) + then pm "" + else + match func.returns with + | `nothing -> pm "" (*TODO: implement manually*) + | `dynamic -> pm ""; (* TODO. implement manually*) + | `fixed 1 -> + pm "\n" ; + if is_method then pm "func(ts *Tensor) Must%s(" gofunc_name + else pm "func Must%s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:false) ; + pm " \n" ; + (* NOTE. No return retVal for in_place method *) + if Func.is_inplace func then + if is_method then + pm " err := ts.%s(%s)\n" gofunc_name go_args_list_notype + else pm " err := %s(%s)\n" gofunc_name go_args_list_notype + else if is_method then + pm " retVal, err := ts.%s(%s)\n" gofunc_name + go_args_list_notype + else + pm " retVal, err := %s(%s)\n" gofunc_name + go_args_list_notype ; + pm " if err != nil { log.Fatal(err) }\n" ; + pm " \n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:false) ; + pm "} \n" + | `fixed _ -> + pm "\n" ; + if is_method then pm "func(ts *Tensor) Must%s(" gofunc_name + else pm "func Must%s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:false) ; + pm " \n" ; + (* NOTE. No return retVal for in_place method *) + if Func.is_inplace func then + if is_method then + pm " err := ts.%s(%s)\n" gofunc_name go_args_list_notype + else pm " err := %s(%s)\n" gofunc_name go_args_list_notype + else if is_method then + pm " %s, err := ts.%s(%s)\n" + (Func.go_return_notype func ~fallible:false) + gofunc_name go_args_list_notype + else + pm " %s, err := %s(%s)\n" + (Func.go_return_notype func ~fallible:false) + gofunc_name go_args_list_notype ; + pm " if err != nil { log.Fatal(err) }\n" ; + pm " \n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:false) ; + pm "} \n" + | `bool -> + pm "\n" ; + if is_method then pm "func(ts *Tensor) Must%s(" gofunc_name + else pm "func Must%s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:false) ; + pm " \n" ; + if is_method then + pm " retVal, err := ts.%s(%s)\n" gofunc_name + go_args_list_notype + else + pm " retVal, err := %s(%s)\n" gofunc_name + go_args_list_notype ; + pm " if err != nil { log.Fatal(err) }\n" ; + pm " \n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:false) ; + pm "} \n" + | `int64_t -> + pm "\n" ; + if is_method then pm "func(ts *Tensor) Must%s(" gofunc_name + else pm "func Must%s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:false) ; + pm " \n" ; + if is_method then + pm " retVal, err := ts.%s(%s)\n" gofunc_name + go_args_list_notype + else + pm " retVal, err := %s(%s)\n" gofunc_name + go_args_list_notype ; + pm " if err != nil { log.Fatal(err) }\n" ; + pm " \n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:false) ; + pm "} \n" + | `double -> + pm "\n" ; + if is_method then pm "func(ts *Tensor) Must%s(" gofunc_name + else pm "func Must%s(" gofunc_name ; + pm "%s" go_args_list ; + pm ")(%s) { \n" (Func.go_return_type func ~fallible:false) ; + pm " \n" ; + if is_method then + pm " retVal, err := ts.%s(%s)\n" gofunc_name + go_args_list_notype + else + pm " retVal, err := %s(%s)\n" gofunc_name + go_args_list_notype ; + pm " if err != nil { log.Fatal(err) }\n" ; + pm " \n" ; + pm " return %s\n" (Func.go_return_notype func ~fallible:false) ; + pm "} \n" ) ; + pm "// End of implementing Tensor ================================= \n" + ) + +let write_ffi funcs filename = + Out_channel.with_file filename ~f:(fun out_ml -> + let pm s = p out_ml s in + pm "package libtch" ; + pm "" ; + pm "// NOTE. THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND!" ; + pm "" ; + pm "//#include \"stdbool.h\" " ; + pm "//#include \"torch_api.h\" " ; + pm "import \"C\"" ; + pm "" ; + pm "import \"unsafe\"" ; + pm "" ; + Map.iteri funcs ~f:(fun ~key:exported_name ~data: (func : Func.t) -> + (* let is_method = *) + (* match func.Func.kind with `method_ -> true | `function_ -> false *) + (* in *) + (* let is_inplace = *) + (* Func.is_inplace func *) + (* + * match exported_name with + * | "add_1" -> true + * | "sub_1" -> true + * | "div_1" -> true + * | "mul_1" -> true + * | _ -> false + * *) + (* in *) + (* NOTE. `torch.__PATTERN` *) + let prefix_2underscore exported_name = + Str.string_match (Str.regexp "^__") exported_name 0 + in + (* NOTE. `torch._PATTERN` *) + let prefix_1underscore exported_name = + Str.string_match (Str.regexp "^_") exported_name 0 + in + (* NOTE. `torch.PATTERN_1` *) + let suffix_1 exported_name = + Str.string_match (Str.regexp ".*_1$") exported_name 0 + in + let ffifunc_name = + if prefix_2underscore exported_name then + "__" ^ Func.go_name exported_name + else if prefix_1underscore exported_name then + "_" ^ Func.go_name exported_name + else if suffix_1 exported_name then + Func.go_name exported_name ^ "_" + else Func.go_name exported_name + in + match func.Func.returns with + | `nothing -> pm "" (*TODO.*) + | `fixed _ -> + pm "func Atg%s(ptr *Ctensor, %s){%s \n\tC.atg_%s(ptr, %s)\n}" + ffifunc_name (Func.c_go_args_list func) + (Func.c_go_args_list_body func) + exported_name + (Func.c_go_args_list_notype func) + | `dynamic -> pm "" (*TODO.*) + | `bool -> + pm "func Atg%s(%s) bool{%s" ffifunc_name + (Func.c_go_args_list func) + (Func.c_go_args_list_body func) ; + pm "\t cResult := C.atg_%s(%s)" exported_name + (Func.c_go_args_list_notype func) ; + pm "\t cbool := *(*int)(unsafe.Pointer(&cResult))" ; + pm "\t if cbool == 1{return true}" ; + pm "\t return false" ; + pm "}" + | `int64_t -> + pm "func Atg%s(%s) int64{%s" ffifunc_name + (Func.c_go_args_list func) + (Func.c_go_args_list_body func) ; + pm "\t cResult := C.atg_%s(%s)" exported_name + (Func.c_go_args_list_notype func) ; + pm "\t return *(*int64)(unsafe.Pointer(&cResult))" ; + pm "}" + | `double -> + pm "func Atg%s(%s) float64{%s" ffifunc_name + (Func.c_go_args_list func) + (Func.c_go_args_list_body func) ; + pm "\t cResult := C.atg_%s(%s)" exported_name + (Func.c_go_args_list_notype func) ; + pm "\t return *(*float64)(unsafe.Pointer(&cResult))" ; + pm "}" + (* TODO: need more implement here *) + (* pm "func Atg%s(%s)(retValPtr *Ctensor)" *) + (* (Func.go_name exported_name) *) + (* (Func.c_go_args_list func) *) ) ) + +let methods = + let c name args = + { Func.name + ; operator_name = name + ; overload_name = "" + ; args + ; returns = `fixed 1 + ; kind = `method_ + } + in + let ca arg_name arg_type = { Func.arg_name; arg_type; default_value = None } in + [ c "grad" [ ca "self" Tensor ] + ; c "set_requires_grad" [ ca "self" Tensor; ca "r" Bool ] + ; c "toType" [ ca "self" Tensor; ca "scalar_type" ScalarType ] + ; c "to" [ ca "self" Tensor; ca "device" Device ] + ] + +let run ~yaml_filename ~cpp_filename ~ffi_filename ~must_wrapper_filename + ~wrapper_filename = + let funcs = read_yaml yaml_filename |> List.concat in + let funcs = methods @ funcs in + printf "Generating code for %d functions.\n%!" (List.length funcs); + (* Generate some unique names for overloaded functions. *) + let funcs = + List.map funcs ~f:(fun func -> Func.operator_name func, func) + |> Map.of_alist_multi (module String) + |> Map.to_alist + |> List.concat_map ~f:(fun (name, funcs) -> + match funcs with + | [] -> assert false + | [ func ] -> [ name, func ] + | funcs -> + let has_empty_overload = + List.exists funcs ~f:(fun (func : Func.t) -> + String.is_empty func.overload_name) + in + List.sort funcs ~compare:(fun (f1 : Func.t) (f2 : Func.t) -> + match Int.compare (String.length f1.name) (String.length f2.name) with + | 0 -> Int.compare (List.length f1.args) (List.length f2.args) + | cmp -> cmp) + |> List.mapi ~f:(fun index (func : Func.t) -> + let operator_name = Func.operator_name func in + let overload_name = String.lowercase func.overload_name in + let name = + if String.is_empty overload_name || (index = 0 && not has_empty_overload) + then operator_name + else if String.is_suffix operator_name ~suffix:"_" + then operator_name ^ overload_name ^ "_" + else operator_name ^ "_" ^ overload_name + in + name, func)) + |> Map.of_alist_exn (module String) + in + write_cpp funcs cpp_filename; + write_ffi funcs ffi_filename ; + write_must_wrapper funcs must_wrapper_filename ; + write_wrapper funcs wrapper_filename + + +let () = + run ~yaml_filename:"gen/pytorch/Declarations-v2.0.0.yaml" + ~cpp_filename:"libtch/torch_api_generated" + ~ffi_filename:"libtch/c-generated.go" + ~must_wrapper_filename:"ts/must-tensor-generated.go" + ~wrapper_filename:"ts/tensor-generated.go" diff --git a/gen/pytorch/Declarations-v2.1.0.yaml b/gen/pytorch/Declarations-v2.1.0.yaml new file mode 100644 index 0000000..e04eeb8 --- /dev/null +++ b/gen/pytorch/Declarations-v2.1.0.yaml @@ -0,0 +1,202710 @@ +- name: _cast_Byte + operator_name: _cast_Byte + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Byte(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cast_Char + operator_name: _cast_Char + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Char(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cast_Double + operator_name: _cast_Double + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Double(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cast_Float + operator_name: _cast_Float + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Float(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cast_Int + operator_name: _cast_Int + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Int(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cast_Long + operator_name: _cast_Long + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Long(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cast_Short + operator_name: _cast_Short + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Short(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cast_Half + operator_name: _cast_Half + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cast_Half(Tensor self, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _backward + operator_name: _backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_backward(Tensor self, Tensor[] inputs, Tensor? gradient=None, bool? retain_graph=None, bool create_graph=False) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: inputs + type: at::TensorList + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: gradient + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: retain_graph + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: create_graph + type: bool + schema_order_cpp_signature: void (const at::Tensor &, at::TensorList, const c10::optional &, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: inputs + type: at::TensorList + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: gradient + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: retain_graph + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: create_graph + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: set_data + operator_name: set_data + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::set_data(Tensor(a!) self, Tensor new_data) -> () + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: new_data + type: const at::Tensor & + schema_order_cpp_signature: void (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: new_data + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: data + operator_name: data + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::data(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_leaf + operator_name: is_leaf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_leaf(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: output_nr + operator_name: output_nr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::output_nr(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _version + operator_name: _version + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_version(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: requires_grad_ + operator_name: requires_grad_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::requires_grad_(Tensor(a!) self, bool requires_grad=True) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: requires_grad + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: requires_grad + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: retain_grad + operator_name: retain_grad + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::retain_grad(Tensor(a!) self) -> () + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: void (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: retains_grad + operator_name: retains_grad + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::retains_grad(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _fw_primal + operator_name: _fw_primal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fw_primal(Tensor(a) self, int level) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_dual + operator_name: _make_dual + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_dual(Tensor(a) primal, Tensor tangent, int level) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: primal + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tangent + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: primal + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tangent + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unpack_dual + operator_name: _unpack_dual + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unpack_dual(Tensor(a) dual, int level) -> (Tensor(a) primal, Tensor tangent) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: dual + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: dual + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: primal + name: primal + type: at::Tensor + - dynamic_type: at::Tensor + field_name: tangent + name: tangent + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _new_zeros_with_same_feature_meta + operator_name: _new_zeros_with_same_feature_meta + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_new_zeros_with_same_feature_meta(Tensor self, Tensor other, *, int self_num_batch_dims=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: self_num_batch_dims + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: self_num_batch_dims + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _has_same_storage_numel + operator_name: _has_same_storage_numel + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_has_same_storage_numel(Tensor self, Tensor other) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rename_ + operator_name: rename_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rename_(Tensor(a!) self, Dimname[]? names) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + name: names + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rename + operator_name: rename + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rename(Tensor(a) self, Dimname[]? names) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + name: names + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: align_to + operator_name: align_to + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::align_to(Tensor(a) self, Dimname[] names) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: names + type: at::DimnameList + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: names + type: at::DimnameList + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: align_to + operator_name: align_to + overload_name: ellipsis_idx + manual_kernel_registration: false + category_override: '' + schema_string: aten::align_to.ellipsis_idx(Tensor(a) self, Dimname[] order, int ellipsis_idx) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: order + type: at::DimnameList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ellipsis_idx + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: order + type: at::DimnameList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ellipsis_idx + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: align_as + operator_name: align_as + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::align_as(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: align_tensors + operator_name: align_tensors + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::align_tensors(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _assert_async + operator_name: _assert_async + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_assert_async(Tensor self) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: void (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _assert_async + operator_name: _assert_async + overload_name: msg + manual_kernel_registration: false + category_override: '' + schema_string: aten::_assert_async.msg(Tensor self, str assert_msg) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: assert_msg + type: c10::string_view + schema_order_cpp_signature: void (const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: assert_msg + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _functional_assert_async + operator_name: _functional_assert_async + overload_name: msg + manual_kernel_registration: false + category_override: '' + schema_string: aten::_functional_assert_async.msg(Tensor self, str assert_msg, Tensor dep_token) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: assert_msg + type: c10::string_view + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dep_token + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: assert_msg + type: c10::string_view + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dep_token + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _assert_tensor_metadata + operator_name: _assert_tensor_metadata + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_assert_tensor_metadata(Tensor a, SymInt[]? size=None, SymInt[]? stride=None, ScalarType? dtype=None) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: a + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: size + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: stride + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: void (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: a + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: size + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: stride + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sym_constrain_range + operator_name: sym_constrain_range + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sym_constrain_range(Scalar size, *, int? min=None, int? max=None) -> () + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: min + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: max + type: c10::optional + schema_order_cpp_signature: void (const at::Scalar &, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: min + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: max + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sym_constrain_range_for_size + operator_name: sym_constrain_range_for_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sym_constrain_range_for_size(Scalar size, *, int? min, int? max) -> () + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: min + type: c10::optional + - annotation: null + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: max + type: c10::optional + schema_order_cpp_signature: void (const at::Scalar &, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: min + type: c10::optional + - annotation: null + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: max + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _functional_sym_constrain_range + operator_name: _functional_sym_constrain_range + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_functional_sym_constrain_range(Scalar size, int? min, int? max, Tensor dep_token) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: min + type: c10::optional + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: max + type: c10::optional + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dep_token + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, c10::optional, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: min + type: c10::optional + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: max + type: c10::optional + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dep_token + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _functional_sym_constrain_range_for_size + operator_name: _functional_sym_constrain_range_for_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_functional_sym_constrain_range_for_size(Scalar size, int? min, int? max, Tensor dep_token) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: min + type: c10::optional + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: max + type: c10::optional + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dep_token + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, c10::optional, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: size + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: min + type: c10::optional + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: max + type: c10::optional + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dep_token + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_dep_token + operator_name: _make_dep_token + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_dep_token(*, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: refine_names + operator_name: refine_names + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::refine_names(Tensor(a) self, Dimname[] names) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: names + type: at::DimnameList + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: names + type: at::DimnameList + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _use_cudnn_ctc_loss + operator_name: _use_cudnn_ctc_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_use_cudnn_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _use_cudnn_ctc_loss + operator_name: _use_cudnn_ctc_loss + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_use_cudnn_ctc_loss.Tensor(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, int blank) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_ctc_loss + operator_name: _cudnn_ctc_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank, bool deterministic, bool zero_infinity) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_ctc_loss + operator_name: _cudnn_ctc_loss + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_ctc_loss.Tensor(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, int blank, bool deterministic, bool zero_infinity) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _use_cudnn_rnn_flatten_weight + operator_name: _use_cudnn_rnn_flatten_weight + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_use_cudnn_rnn_flatten_weight() -> bool + arguments: [] + schema_order_cpp_signature: bool () + schema_order_arguments: [] + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cudnn_rnn_flatten_weight + operator_name: _cudnn_rnn_flatten_weight + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_rnn_flatten_weight(Tensor[] weight_arr, int weight_stride0, SymInt input_size, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, bool bidirectional) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight_arr + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: input_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + schema_order_cpp_signature: at::Tensor (at::TensorList, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight_arr + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: input_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_rnn + operator_name: _cudnn_rnn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_rnn(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight_buf + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, int64_t, const c10::optional &, const at::Tensor &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight_buf + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_rnn_backward + operator_name: _cudnn_rnn_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_rnn_backward(Tensor input, Tensor[] weight, int weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state, Tensor reserve, bool[4] output_mask) -> (Tensor, Tensor, Tensor, Tensor[]) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple> (const at::Tensor &, at::TensorList, int64_t, const at::Tensor &, const at::Tensor &, const c10::optional &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &, const at::Tensor &, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::TensorList + name: result3 + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_init_dropout_state + operator_name: _cudnn_init_dropout_state + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_init_dropout_state(float dropout, bool train, int dropout_seed, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dropout_seed + type: int64_t + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (double, bool, int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dropout_seed + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _debug_has_internal_overlap + operator_name: _debug_has_internal_overlap + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_debug_has_internal_overlap(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _fused_dropout + operator_name: _fused_dropout + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_dropout(Tensor self, float p, Generator? generator=None) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _masked_scale + operator_name: _masked_scale + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_masked_scale(Tensor self, Tensor mask, float scale) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_dropout + operator_name: native_dropout + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_dropout(Tensor input, float p, bool? train) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: true + name: train + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: true + name: train + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_dropout_backward + operator_name: native_dropout_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_dropout_backward(Tensor grad_output, Tensor mask, float scale) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sobol_engine_draw + operator_name: _sobol_engine_draw + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sobol_engine_draw(Tensor quasi, int n, Tensor sobolstate, int dimension, int num_generated, ScalarType? dtype) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: quasi + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sobolstate + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_generated + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, const at::Tensor &, int64_t, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: quasi + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sobolstate + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_generated + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sobol_engine_ff_ + operator_name: _sobol_engine_ff_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sobol_engine_ff_(Tensor(a!) self, int n, Tensor sobolstate, int dimension, int num_generated) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sobolstate + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_generated + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sobolstate + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_generated + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sobol_engine_scramble_ + operator_name: _sobol_engine_scramble_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sobol_engine_scramble_(Tensor(a!) self, Tensor ltm, int dimension) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ltm + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ltm + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sobol_engine_initialize_state_ + operator_name: _sobol_engine_initialize_state_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sobol_engine_initialize_state_(Tensor(a!) self, int dimension) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _reshape_from_tensor + operator_name: _reshape_from_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_reshape_from_tensor(Tensor self, Tensor shape) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: shape + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: shape + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _shape_as_tensor + operator_name: _shape_as_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_shape_as_tensor(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: dropout + operator_name: dropout + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::dropout(Tensor input, float p, bool train) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: dropout_ + operator_name: dropout_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: feature_dropout + operator_name: feature_dropout + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::feature_dropout(Tensor input, float p, bool train) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: feature_dropout_ + operator_name: feature_dropout_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::feature_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: alpha_dropout + operator_name: alpha_dropout + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::alpha_dropout(Tensor input, float p, bool train) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: alpha_dropout_ + operator_name: alpha_dropout_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::alpha_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: feature_alpha_dropout + operator_name: feature_alpha_dropout + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::feature_alpha_dropout(Tensor input, float p, bool train) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: feature_alpha_dropout_ + operator_name: feature_alpha_dropout_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::feature_alpha_dropout_(Tensor(a!) self, float p, bool train) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: abs + operator_name: abs + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::abs(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: abs_ + operator_name: abs_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::abs_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: abs_out + operator_name: abs + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: absolute + operator_name: absolute + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::absolute(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: absolute_ + operator_name: absolute_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::absolute_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: absolute_out + operator_name: absolute + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::absolute.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: angle + operator_name: angle + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::angle(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: angle_out + operator_name: angle + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::angle.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_as_real + operator_name: view_as_real + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_as_real(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_as_complex + operator_name: view_as_complex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_as_complex(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sgn + operator_name: sgn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sgn(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sgn_ + operator_name: sgn_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sgn_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sgn_out + operator_name: sgn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sgn.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: chalf + operator_name: chalf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::chalf(Tensor self, *, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: real + operator_name: real + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::real(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: imag + operator_name: imag + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::imag(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _conj + operator_name: _conj + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_conj(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: conj + operator_name: conj + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conj(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _conj_physical + operator_name: _conj_physical + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_conj_physical(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: conj_physical + operator_name: conj_physical + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conj_physical(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conj_physical_out + operator_name: conj_physical + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::conj_physical.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: conj_physical_ + operator_name: conj_physical_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conj_physical_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: resolve_conj + operator_name: resolve_conj + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resolve_conj(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: resolve_neg + operator_name: resolve_neg + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resolve_neg(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _neg_view + operator_name: _neg_view + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_neg_view(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: acos + operator_name: acos + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::acos(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: acos_ + operator_name: acos_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::acos_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: acos_out + operator_name: acos + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::acos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arccos + operator_name: arccos + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arccos(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arccos_ + operator_name: arccos_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arccos_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arccos_out + operator_name: arccos + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arccos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: avg_pool1d + operator_name: avg_pool1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: 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 + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: adaptive_avg_pool1d + operator_name: adaptive_avg_pool1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_avg_pool1d(Tensor self, int[1] output_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: adaptive_max_pool1d + operator_name: adaptive_max_pool1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool1d(Tensor self, int[1] output_size) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: add + operator_name: add + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::add.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: add_ + operator_name: add_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::add_.Tensor(Tensor(a!) self, Tensor other, *, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: add_out + operator_name: add + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _add_relu + operator_name: _add_relu + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_add_relu.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _add_relu_ + operator_name: _add_relu_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_add_relu_.Tensor(Tensor(a!) self, Tensor other, *, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _add_relu_out + operator_name: _add_relu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_add_relu.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _add_relu + operator_name: _add_relu + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_add_relu.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _add_relu_ + operator_name: _add_relu_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_add_relu_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: add + operator_name: add + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::add.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: add_ + operator_name: add_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::add_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addmv + operator_name: addmv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addmv(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addmv_ + operator_name: addmv_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addmv_(Tensor(a!) self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addmv_out + operator_name: addmv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::addmv.out(Tensor self, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addr + operator_name: addr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addr(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addr_ + operator_name: addr_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addr_(Tensor(a!) self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addr_out + operator_name: addr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::addr.out(Tensor self, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: affine_grid_generator + operator_name: affine_grid_generator + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::affine_grid_generator(Tensor theta, SymInt[] size, bool align_corners) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: affine_grid_generator_backward + operator_name: affine_grid_generator_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::affine_grid_generator_backward(Tensor grad, SymInt[] size, bool align_corners) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _is_all_true + operator_name: _is_all_true + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_is_all_true(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _is_any_true + operator_name: _is_any_true + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_is_any_true(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_check_tensor + operator_name: _test_check_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_check_tensor(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _test_functorch_fallback + operator_name: _test_functorch_fallback + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_functorch_fallback(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: all + operator_name: all + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::all.dim(Tensor self, int dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: all_out + operator_name: all + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::all.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: all + operator_name: all + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::all.dimname(Tensor self, Dimname dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: all_out + operator_name: all + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::all.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: allclose + operator_name: allclose + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::allclose(Tensor self, Tensor other, float rtol=1e-05, float atol=1e-08, bool equal_nan=False) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: rtol + type: double + - annotation: null + default: 1.0e-08 + dynamic_type: double + is_nullable: false + name: atol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: equal_nan + type: bool + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &, double, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: rtol + type: double + - annotation: null + default: 1.0e-08 + dynamic_type: double + is_nullable: false + name: atol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: equal_nan + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: any + operator_name: any + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::any.dim(Tensor self, int dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: any_out + operator_name: any + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::any.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: any + operator_name: any + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::any.dimname(Tensor self, Dimname dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: any_out + operator_name: any + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::any.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arange + operator_name: arange + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arange(Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arange + operator_name: arange + overload_name: start + manual_kernel_registration: false + category_override: '' + schema_string: aten::arange.start(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arange + operator_name: arange + overload_name: start_step + manual_kernel_registration: false + category_override: '' + schema_string: aten::arange.start_step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Scalar &, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arange_out + operator_name: arange + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arange.out(Scalar end, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arange_out + operator_name: arange + overload_name: start_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arange.start_out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _dim_arange + operator_name: _dim_arange + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_dim_arange(Tensor like, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: like + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: like + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: argmax + operator_name: argmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::argmax(Tensor self, int? dim=None, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: argmax_out + operator_name: argmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::argmax.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: argmin + operator_name: argmin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::argmin(Tensor self, int? dim=None, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: argmin_out + operator_name: argmin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::argmin.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: acosh + operator_name: acosh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::acosh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: acosh_ + operator_name: acosh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::acosh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: acosh_out + operator_name: acosh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::acosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arccosh + operator_name: arccosh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arccosh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arccosh_ + operator_name: arccosh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arccosh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arccosh_out + operator_name: arccosh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arccosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: asinh + operator_name: asinh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::asinh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: asinh_ + operator_name: asinh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::asinh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: asinh_out + operator_name: asinh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::asinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arcsinh + operator_name: arcsinh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arcsinh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arcsinh_ + operator_name: arcsinh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arcsinh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arcsinh_out + operator_name: arcsinh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arcsinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atanh + operator_name: atanh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atanh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: atanh_ + operator_name: atanh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atanh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: atanh_out + operator_name: atanh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::atanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arctanh + operator_name: arctanh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctanh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arctanh_ + operator_name: arctanh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctanh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arctanh_out + operator_name: arctanh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: as_strided + operator_name: as_strided + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::as_strided(Tensor(a) self, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: as_strided_ + operator_name: as_strided_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::as_strided_(Tensor(a!) self, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: const at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: asin + operator_name: asin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::asin(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: asin_ + operator_name: asin_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::asin_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: asin_out + operator_name: asin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::asin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arcsin + operator_name: arcsin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arcsin(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arcsin_ + operator_name: arcsin_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arcsin_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arcsin_out + operator_name: arcsin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arcsin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atan + operator_name: atan + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atan(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: atan_ + operator_name: atan_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atan_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: atan_out + operator_name: atan + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::atan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arctan + operator_name: arctan + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctan(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arctan_ + operator_name: arctan_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctan_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arctan_out + operator_name: arctan + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atleast_1d + operator_name: atleast_1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atleast_1d(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atleast_1d + operator_name: atleast_1d + overload_name: Sequence + manual_kernel_registration: false + category_override: '' + schema_string: aten::atleast_1d.Sequence(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atleast_2d + operator_name: atleast_2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atleast_2d(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atleast_2d + operator_name: atleast_2d + overload_name: Sequence + manual_kernel_registration: false + category_override: '' + schema_string: aten::atleast_2d.Sequence(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atleast_3d + operator_name: atleast_3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atleast_3d(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: atleast_3d + operator_name: atleast_3d + overload_name: Sequence + manual_kernel_registration: false + category_override: '' + schema_string: aten::atleast_3d.Sequence(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: baddbmm + operator_name: baddbmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::baddbmm(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: baddbmm_ + operator_name: baddbmm_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::baddbmm_(Tensor(a!) self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: baddbmm_out + operator_name: baddbmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::baddbmm.out(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bartlett_window + operator_name: bartlett_window + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::bartlett_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bartlett_window + operator_name: bartlett_window + overload_name: periodic + manual_kernel_registration: false + category_override: '' + schema_string: aten::bartlett_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm + operator_name: batch_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantized_batch_norm + operator_name: quantized_batch_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor var, float eps, float output_scale, int output_zero_point) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: output_scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: output_zero_point + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: output_scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: output_zero_point + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _batch_norm_impl_index + operator_name: _batch_norm_impl_index + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_batch_norm_impl_index(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> (Tensor, Tensor, Tensor, Tensor, int) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: int64_t + name: result4 + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _batch_norm_impl_index_backward + operator_name: _batch_norm_impl_index_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_batch_norm_impl_index_backward(int impl_index, Tensor input, Tensor grad_output, Tensor? weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var_transform, bool train, float eps, bool[3] output_mask, Tensor reservedSpace) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: impl_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var_transform + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reservedSpace + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (int64_t, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, ::std::array, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: impl_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var_transform + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reservedSpace + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bernoulli + operator_name: bernoulli + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli(Tensor self, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bernoulli_out + operator_name: bernoulli + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bernoulli_ + operator_name: bernoulli_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli_.Tensor(Tensor(a!) self, Tensor p, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: p + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: p + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bernoulli_ + operator_name: bernoulli_ + overload_name: float + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli_.float(Tensor(a!) self, float p=0.5, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bernoulli + operator_name: bernoulli + overload_name: p + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli.p(Tensor self, float p, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bilinear + operator_name: bilinear + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::bilinear(Tensor input1, Tensor input2, Tensor weight, Tensor? bias=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: binary_cross_entropy + operator_name: binary_cross_entropy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::binary_cross_entropy(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: binary_cross_entropy_out + operator_name: binary_cross_entropy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::binary_cross_entropy.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: binary_cross_entropy_backward + operator_name: binary_cross_entropy_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::binary_cross_entropy_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: binary_cross_entropy_backward_out + operator_name: binary_cross_entropy_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::binary_cross_entropy_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: binary_cross_entropy_with_logits + operator_name: binary_cross_entropy_with_logits + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::binary_cross_entropy_with_logits(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: pos_weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: pos_weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bincount + operator_name: bincount + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::bincount(Tensor self, Tensor? weights=None, int minlength=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weights + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: minlength + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weights + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: minlength + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_not + operator_name: bitwise_not + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_not(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_not_ + operator_name: bitwise_not_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_not_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_not_out + operator_name: bitwise_not + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copysign_out + operator_name: copysign + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::copysign.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copysign + operator_name: copysign + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::copysign.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copysign_ + operator_name: copysign_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::copysign_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copysign + operator_name: copysign + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::copysign.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copysign_ + operator_name: copysign_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::copysign_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copysign_out + operator_name: copysign + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::copysign.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_not + operator_name: logical_not + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_not(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_not_ + operator_name: logical_not_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_not_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_not_out + operator_name: logical_not + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_xor + operator_name: logical_xor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_xor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_xor_ + operator_name: logical_xor_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_xor_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_xor_out + operator_name: logical_xor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_xor.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_and + operator_name: logical_and + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_and(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_and_ + operator_name: logical_and_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_and_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_and_out + operator_name: logical_and + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_and.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_or + operator_name: logical_or + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_or(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_or_ + operator_name: logical_or_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_or_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logical_or_out + operator_name: logical_or + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logical_or.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: blackman_window + operator_name: blackman_window + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: blackman_window + operator_name: blackman_window + overload_name: periodic + manual_kernel_registration: false + category_override: '' + schema_string: aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bmm + operator_name: bmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::bmm(Tensor self, Tensor mat2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bmm_out + operator_name: bmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: broadcast_tensors + operator_name: broadcast_tensors + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::broadcast_tensors(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: broadcast_to + operator_name: broadcast_to + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::broadcast_to(Tensor(a) self, SymInt[] size) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_broadcast_to + operator_name: _sparse_broadcast_to + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_broadcast_to(Tensor(a) self, int[] size) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cat + operator_name: cat + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cat(Tensor[] tensors, int dim=0) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::ITensorListRef & + is_nullable: false + name: tensors + type: const at::ITensorListRef & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::ITensorListRef &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: const at::ITensorListRef & + is_nullable: false + name: tensors + type: const at::ITensorListRef & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cat_out + operator_name: cat + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::ITensorListRef & + is_nullable: false + name: tensors + type: const at::ITensorListRef & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::ITensorListRef &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::ITensorListRef & + is_nullable: false + name: tensors + type: const at::ITensorListRef & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cat + operator_name: cat + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::cat.names(Tensor[] tensors, Dimname dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (at::TensorList, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cat_out + operator_name: cat + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Dimname, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concat + operator_name: concat + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::concat(Tensor[] tensors, int dim=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (at::TensorList, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concat_out + operator_name: concat + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::concat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::TensorList, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concat + operator_name: concat + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::concat.names(Tensor[] tensors, Dimname dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (at::TensorList, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concat_out + operator_name: concat + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::concat.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Dimname, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concatenate + operator_name: concatenate + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::concatenate(Tensor[] tensors, int dim=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (at::TensorList, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concatenate_out + operator_name: concatenate + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::concatenate.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::TensorList, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concatenate + operator_name: concatenate + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::concatenate.names(Tensor[] tensors, Dimname dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (at::TensorList, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: concatenate_out + operator_name: concatenate + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::concatenate.names_out(Tensor[] tensors, Dimname dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Dimname, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: block_diag + operator_name: block_diag + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::block_diag(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ceil + operator_name: ceil + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ceil(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ceil_ + operator_name: ceil_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ceil_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ceil_out + operator_name: ceil + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ceil.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: chain_matmul + operator_name: chain_matmul + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::chain_matmul(Tensor[] matrices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: matrices + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: matrices + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: chain_matmul_out + operator_name: chain_matmul + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::chain_matmul.out(Tensor[] matrices, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: matrices + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: matrices + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: unsafe_chunk + operator_name: unsafe_chunk + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsafe_chunk(Tensor self, int chunks, int dim=0) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: chunks + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: chunks + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: chunk + operator_name: chunk + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::chunk(Tensor(a -> *) self, int chunks, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: chunks + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: chunks + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: tensor_split + operator_name: tensor_split + overload_name: sections + manual_kernel_registration: false + category_override: '' + schema_string: aten::tensor_split.sections(Tensor(a -> *) self, SymInt sections, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: tensor_split + operator_name: tensor_split + overload_name: indices + manual_kernel_registration: false + category_override: '' + schema_string: aten::tensor_split.indices(Tensor(a -> *) self, SymInt[] indices, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: tensor_split + operator_name: tensor_split + overload_name: tensor_indices_or_sections + manual_kernel_registration: false + category_override: '' + schema_string: aten::tensor_split.tensor_indices_or_sections(Tensor(a -> *) self, Tensor tensor_indices_or_sections, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor_indices_or_sections + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor_indices_or_sections + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: clamp + operator_name: clamp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp(Tensor self, Scalar? min=None, Scalar? max=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp + operator_name: clamp + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp.Tensor(Tensor self, Tensor? min=None, Tensor? max=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_ + operator_name: clamp_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_(Tensor(a!) self, Scalar? min=None, Scalar? max=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_ + operator_name: clamp_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_.Tensor(Tensor(a!) self, Tensor? min=None, Tensor? max=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_out + operator_name: clamp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_out + operator_name: clamp + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp.Tensor_out(Tensor self, Tensor? min=None, Tensor? max=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_max + operator_name: clamp_max + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_max(Tensor self, Scalar max) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_max + operator_name: clamp_max + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_max.Tensor(Tensor self, Tensor max) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: max + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: max + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_max_ + operator_name: clamp_max_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_max_(Tensor(a!) self, Scalar max) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_max_ + operator_name: clamp_max_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_max_.Tensor(Tensor(a!) self, Tensor max) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: max + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: max + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_max_out + operator_name: clamp_max + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_max.out(Tensor self, Scalar max, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_max_out + operator_name: clamp_max + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_max.Tensor_out(Tensor self, Tensor max, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: max + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: max + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_min + operator_name: clamp_min + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_min(Tensor self, Scalar min) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_min + operator_name: clamp_min + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_min.Tensor(Tensor self, Tensor min) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: min + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: min + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_min_ + operator_name: clamp_min_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_min_(Tensor(a!) self, Scalar min) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_min_ + operator_name: clamp_min_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_min_.Tensor(Tensor(a!) self, Tensor min) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: min + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: min + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_min_out + operator_name: clamp_min + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_min.out(Tensor self, Scalar min, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clamp_min_out + operator_name: clamp_min + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clamp_min.Tensor_out(Tensor self, Tensor min, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: min + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: min + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: clip + operator_name: clip + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clip(Tensor self, Scalar? min=None, Scalar? max=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: clip + operator_name: clip + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clip.Tensor(Tensor self, Tensor? min=None, Tensor? max=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: clip_ + operator_name: clip_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clip_(Tensor(a!) self, Scalar? min=None, Scalar? max=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: clip_ + operator_name: clip_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::clip_.Tensor(Tensor(a!) self, Tensor? min=None, Tensor? max=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: clip_out + operator_name: clip + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clip.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: max + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: clip_out + operator_name: clip + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clip.Tensor_out(Tensor self, Tensor? min=None, Tensor? max=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: min + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: max + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cudnn_is_acceptable + operator_name: cudnn_is_acceptable + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_is_acceptable(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: complex + operator_name: complex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::complex(Tensor real, Tensor imag) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: real + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: imag + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: real + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: imag + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: complex_out + operator_name: complex + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::complex.out(Tensor real, Tensor imag, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: real + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: imag + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: real + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: imag + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: polar + operator_name: polar + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::polar(Tensor abs, Tensor angle) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: abs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: angle + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: abs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: angle + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: polar_out + operator_name: polar + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::polar.out(Tensor abs, Tensor angle, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: abs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: angle + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: abs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: angle + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: constant_pad_nd + operator_name: constant_pad_nd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::constant_pad_nd(Tensor self, SymInt[] pad, Scalar value=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: contiguous + operator_name: contiguous + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::contiguous(Tensor(a) self, *, MemoryFormat memory_format=contiguous_format) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: false + kwarg_only: true + name: memory_format + type: at::MemoryFormat + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::MemoryFormat) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: false + kwarg_only: true + name: memory_format + type: at::MemoryFormat + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: convolution + operator_name: convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution(Tensor input, Tensor weight, Tensor? bias, int[] stride, SymInt[] padding, int[] dilation, bool transposed, SymInt[] output_padding, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: convolution_backward + operator_name: convolution_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution_backward(Tensor grad_output, Tensor input, Tensor weight, SymInt[]? bias_sizes, int[] stride, SymInt[] padding, int[] dilation, bool transposed, SymInt[] output_padding, int groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: bias_sizes + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: bias_sizes + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: convolution_overrideable + operator_name: convolution_overrideable + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution_overrideable(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: convolution_backward_overrideable + operator_name: convolution_backward_overrideable + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution_backward_overrideable(Tensor grad_output, Tensor input, Tensor weight, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: grad_input + name: grad_input + type: at::Tensor + - dynamic_type: at::Tensor + field_name: grad_weight + name: grad_weight + type: at::Tensor + - dynamic_type: at::Tensor + field_name: grad_bias + name: grad_bias + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _convolution + operator_name: _convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convolution(Tensor input, Tensor weight, Tensor? bias, int[] stride, SymInt[] padding, int[] dilation, bool transposed, SymInt[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, bool, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _convolution + operator_name: _convolution + overload_name: deprecated + manual_kernel_registration: false + category_override: '' + schema_string: 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 + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _convolution_mode + operator_name: _convolution_mode + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convolution_mode(Tensor input, Tensor weight, Tensor? bias, int[] stride, str padding, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, c10::string_view, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _convolution_double_backward + operator_name: _convolution_double_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convolution_double_backward(Tensor? ggI, Tensor? ggW, Tensor? ggb, Tensor gO, Tensor weight, Tensor self, int[] stride, SymInt[] padding, int[] dilation, bool transposed, SymInt[] output_padding, int groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: ggI + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: ggW + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: ggb + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: gO + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const c10::optional &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: ggI + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: ggW + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: ggb + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: gO + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv1d + operator_name: conv1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv1d(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, SymInt[1] padding=0, int[1] dilation=1, int groups=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv2d + operator_name: conv2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv2d(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, SymInt[2] padding=0, int[2] dilation=1, int groups=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv3d + operator_name: conv3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv3d(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0, int[3] dilation=1, int groups=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv1d + operator_name: conv1d + overload_name: padding + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv1d.padding(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, str padding="valid", int[1] dilation=1, int groups=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: '"valid"' + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, c10::string_view, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: '"valid"' + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv2d + operator_name: conv2d + overload_name: padding + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv2d.padding(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, str padding="valid", int[2] dilation=1, int groups=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: '"valid"' + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, c10::string_view, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: '"valid"' + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv3d + operator_name: conv3d + overload_name: padding + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv3d.padding(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, str padding="valid", int[3] dilation=1, int groups=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: '"valid"' + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, c10::string_view, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: '"valid"' + dynamic_type: c10::string_view + is_nullable: false + name: padding + type: c10::string_view + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv_tbc + operator_name: conv_tbc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_tbc(Tensor self, Tensor weight, Tensor bias, int pad=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: pad + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: pad + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: conv_tbc_backward + operator_name: conv_tbc_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_tbc_backward(Tensor self, Tensor input, Tensor weight, Tensor bias, int pad) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: pad + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: pad + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv_transpose1d + operator_name: conv_transpose1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_transpose1d(Tensor input, Tensor weight, Tensor? bias=None, int[1] stride=1, SymInt[1] padding=0, SymInt[1] output_padding=0, int groups=1, int[1] dilation=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv_transpose2d + operator_name: conv_transpose2d + overload_name: input + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_transpose2d.input(Tensor input, Tensor weight, Tensor? bias=None, int[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, int groups=1, int[2] dilation=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: conv_transpose3d + operator_name: conv_transpose3d + overload_name: input + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_transpose3d.input(Tensor input, Tensor weight, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0, SymInt[3] output_padding=0, int groups=1, int[3] dilation=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: copy + operator_name: copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::copy(Tensor self, Tensor src, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copy_ + operator_name: copy_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::copy_(Tensor(a!) self, Tensor src, bool non_blocking=False) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _copy_from + operator_name: _copy_from + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_copy_from(Tensor self, Tensor dst, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _copy_from_and_resize + operator_name: _copy_from_and_resize + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_copy_from_and_resize(Tensor self, Tensor dst) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cos + operator_name: cos + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cos(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cos_ + operator_name: cos_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cos_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cos_out + operator_name: cos + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cosh + operator_name: cosh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cosh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cosh_ + operator_name: cosh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cosh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cosh_out + operator_name: cosh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cosine_embedding_loss + operator_name: cosine_embedding_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cosine_embedding_loss(Tensor input1, Tensor input2, Tensor target, float margin=0.0, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: count_nonzero + operator_name: count_nonzero + overload_name: dim_IntList + manual_kernel_registration: false + category_override: '' + schema_string: aten::count_nonzero.dim_IntList(Tensor self, int[] dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: count_nonzero + operator_name: count_nonzero + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::count_nonzero(Tensor self, int? dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cov + operator_name: cov + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cov(Tensor self, *, int correction=1, Tensor? fweights=None, Tensor? aweights=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: correction + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: fweights + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: aweights + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: correction + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: fweights + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: aweights + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: corrcoef + operator_name: corrcoef + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::corrcoef(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cudnn_affine_grid_generator + operator_name: cudnn_affine_grid_generator + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_affine_grid_generator(Tensor theta, int N, int C, int H, int W) -> Tensor grid + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: grid + name: grid + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_affine_grid_generator_backward + operator_name: cudnn_affine_grid_generator_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_affine_grid_generator_backward(Tensor grad, int N, int C, int H, int W) -> Tensor grad_theta + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: grad_theta + name: grad_theta + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_batch_norm + operator_name: cudnn_batch_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon) -> (Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_batch_norm_backward + operator_name: cudnn_batch_norm_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_batch_norm_backward(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, float epsilon, Tensor reserveSpace) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserveSpace + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, double, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserveSpace + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution + operator_name: cudnn_convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution(Tensor self, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution_transpose + operator_name: cudnn_convolution_transpose + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution_transpose(Tensor self, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mps_convolution_transpose + operator_name: _mps_convolution_transpose + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mps_convolution_transpose(Tensor self, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mps_convolution_transpose_backward + operator_name: mps_convolution_transpose_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mps_convolution_transpose_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool[2] output_mask) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution_relu + operator_name: cudnn_convolution_relu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution_relu(Tensor self, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution_add_relu + operator_name: cudnn_convolution_add_relu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution_add_relu(Tensor self, Tensor weight, Tensor z, Scalar? alpha, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: alpha + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: alpha + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_grid_sampler + operator_name: cudnn_grid_sampler + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_grid_sampler(Tensor self, Tensor grid) -> Tensor output + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_grid_sampler_backward + operator_name: cudnn_grid_sampler_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_grid_sampler_backward(Tensor self, Tensor grid, Tensor grad_output) -> (Tensor grad_self, Tensor grad_grid) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: grad_self + name: grad_self + type: at::Tensor + - dynamic_type: at::Tensor + field_name: grad_grid + name: grad_grid + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cummax + operator_name: cummax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummax(Tensor self, int dim) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cummax_out + operator_name: cummax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummax.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cummax + operator_name: cummax + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummax.dimname(Tensor self, Dimname dim) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cummax_out + operator_name: cummax + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummax.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cummax_helper + operator_name: _cummax_helper + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cummax_helper(Tensor self, Tensor(a!) values, Tensor(b!) indices, int dim) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: values + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: void (const at::Tensor &, at::Tensor &, at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: values + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cummin + operator_name: cummin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummin(Tensor self, int dim) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cummin_out + operator_name: cummin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummin.out(Tensor self, int dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cummin + operator_name: cummin + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummin.dimname(Tensor self, Dimname dim) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cummin_out + operator_name: cummin + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummin.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cummin_helper + operator_name: _cummin_helper + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cummin_helper(Tensor self, Tensor(a!) values, Tensor(b!) indices, int dim) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: values + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: void (const at::Tensor &, at::Tensor &, at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: values + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cummaxmin_backward + operator_name: cummaxmin_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cummaxmin_backward(Tensor grad, Tensor input, Tensor indices, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumprod + operator_name: cumprod + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumprod(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cumprod_ + operator_name: cumprod_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumprod_(Tensor(a!) self, int dim, *, ScalarType? dtype=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cumprod_out + operator_name: cumprod + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumprod.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cumprod + operator_name: cumprod + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumprod.dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumprod_ + operator_name: cumprod_ + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumprod_.dimname(Tensor(a!) self, Dimname dim, *, ScalarType? dtype=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumprod_out + operator_name: cumprod + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumprod.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumprod_backward + operator_name: cumprod_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumprod_backward(Tensor grad, Tensor input, int dim, Tensor output) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumsum + operator_name: cumsum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumsum(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cumsum_ + operator_name: cumsum_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumsum_(Tensor(a!) self, int dim, *, ScalarType? dtype=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cumsum_out + operator_name: cumsum + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumsum.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cumsum + operator_name: cumsum + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumsum.dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumsum_ + operator_name: cumsum_ + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumsum_.dimname(Tensor(a!) self, Dimname dim, *, ScalarType? dtype=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumsum_out + operator_name: cumsum + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumsum.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumulative_trapezoid + operator_name: cumulative_trapezoid + overload_name: x + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumulative_trapezoid.x(Tensor y, Tensor x, *, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cumulative_trapezoid + operator_name: cumulative_trapezoid + overload_name: dx + manual_kernel_registration: false + category_override: '' + schema_string: aten::cumulative_trapezoid.dx(Tensor y, *, Scalar dx=1, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: dx + type: const at::Scalar & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: dx + type: const at::Scalar & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ctc_loss + operator_name: ctc_loss + overload_name: IntList + manual_kernel_registration: false + category_override: '' + schema_string: aten::ctc_loss.IntList(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank=0, int reduction=Mean, bool zero_infinity=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ctc_loss + operator_name: ctc_loss + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::ctc_loss.Tensor(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, int blank=0, int reduction=Mean, bool zero_infinity=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _ctc_loss + operator_name: _ctc_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_ctc_loss(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank=0, bool zero_infinity=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _ctc_loss + operator_name: _ctc_loss + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_ctc_loss.Tensor(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, int blank=0, bool zero_infinity=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _ctc_loss_backward + operator_name: _ctc_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_ctc_loss_backward(Tensor grad, Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: neg_log_likelihood + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_alpha + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: neg_log_likelihood + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_alpha + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _ctc_loss_backward + operator_name: _ctc_loss_backward + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_ctc_loss_backward.Tensor(Tensor grad, Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: neg_log_likelihood + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_alpha + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: neg_log_likelihood + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_alpha + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: diag_embed + operator_name: diag_embed + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diag_embed(Tensor self, int offset=0, int dim1=-2, int dim2=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: -2 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: -2 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: diagflat + operator_name: diagflat + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagflat(Tensor self, int offset=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: diagonal + operator_name: diagonal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal(Tensor(a) self, int offset=0, int dim1=0, int dim2=1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_diagonal + operator_name: linalg_diagonal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_diagonal(Tensor(a) A, *, int offset=0, int dim1=-2, int dim2=-1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: offset + type: int64_t + - annotation: null + default: -2 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim1 + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: offset + type: int64_t + - annotation: null + default: -2 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim1 + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim2 + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: diagonal + operator_name: diagonal + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal.Dimname(Tensor(a) self, *, Dimname outdim, Dimname dim1, Dimname dim2, int offset=0) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: outdim + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim1 + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim2 + type: at::Dimname + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: offset + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, at::Dimname, at::Dimname, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: outdim + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim1 + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim2 + type: at::Dimname + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: offset + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: diagonal_backward + operator_name: diagonal_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal_backward(Tensor grad_output, SymInt[] input_sizes, int offset, int dim1, int dim2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: fill_diagonal_ + operator_name: fill_diagonal_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fill_diagonal_(Tensor(a!) self, Scalar fill_value, bool wrap=False) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: wrap + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: wrap + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: diff + operator_name: diff + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diff(Tensor self, int n=1, int dim=-1, Tensor? prepend=None, Tensor? append=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: prepend + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: append + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: prepend + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: append + type: const c10::optional & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: diff_out + operator_name: diff + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::diff.out(Tensor self, int n=1, int dim=-1, Tensor? prepend=None, Tensor? append=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: prepend + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: append + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, const c10::optional &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: prepend + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: append + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gradient + operator_name: gradient + overload_name: scalarint + manual_kernel_registration: false + category_override: '' + schema_string: aten::gradient.scalarint(Tensor self, *, Scalar? spacing=None, int? dim=None, int edge_order=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: spacing + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, const c10::optional &, c10::optional, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: spacing + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gradient + operator_name: gradient + overload_name: scalararray + manual_kernel_registration: false + category_override: '' + schema_string: aten::gradient.scalararray(Tensor self, *, Scalar spacing, int[] dim, int edge_order=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: spacing + type: const at::Scalar & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, const at::Scalar &, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: spacing + type: const at::Scalar & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gradient + operator_name: gradient + overload_name: array + manual_kernel_registration: false + category_override: '' + schema_string: aten::gradient.array(Tensor self, *, int[] dim, int edge_order=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gradient + operator_name: gradient + overload_name: scalarrayint + manual_kernel_registration: false + category_override: '' + schema_string: aten::gradient.scalarrayint(Tensor self, *, Scalar[] spacing, int? dim=None, int edge_order=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + kwarg_only: true + name: spacing + type: at::ArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::ArrayRef, c10::optional, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + kwarg_only: true + name: spacing + type: at::ArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gradient + operator_name: gradient + overload_name: scalarrayarray + manual_kernel_registration: false + category_override: '' + schema_string: aten::gradient.scalarrayarray(Tensor self, *, Scalar[] spacing, int[] dim, int edge_order=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + kwarg_only: true + name: spacing + type: at::ArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::ArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + kwarg_only: true + name: spacing + type: at::ArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gradient + operator_name: gradient + overload_name: tensorarrayint + manual_kernel_registration: false + category_override: '' + schema_string: aten::gradient.tensorarrayint(Tensor self, *, Tensor[] spacing, int? dim=None, int edge_order=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + kwarg_only: true + name: spacing + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::TensorList, c10::optional, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + kwarg_only: true + name: spacing + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gradient + operator_name: gradient + overload_name: tensorarray + manual_kernel_registration: false + category_override: '' + schema_string: aten::gradient.tensorarray(Tensor self, *, Tensor[] spacing, int[] dim, int edge_order=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + kwarg_only: true + name: spacing + type: at::TensorList + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::TensorList, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + kwarg_only: true + name: spacing + type: at::TensorList + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + kwarg_only: true + name: dim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: edge_order + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: div + operator_name: div + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_ + operator_name: div_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::div_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_out + operator_name: div + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div + operator_name: div + overload_name: Tensor_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.Tensor_mode(Tensor self, Tensor other, *, str? rounding_mode) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_ + operator_name: div_ + overload_name: Tensor_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::div_.Tensor_mode(Tensor(a!) self, Tensor other, *, str? rounding_mode) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_out + operator_name: div + overload_name: out_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div + operator_name: div + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_ + operator_name: div_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::div_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div + operator_name: div + overload_name: Scalar_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.Scalar_mode(Tensor self, Scalar other, *, str? rounding_mode) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_ + operator_name: div_ + overload_name: Scalar_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::div_.Scalar_mode(Tensor(a!) self, Scalar other, *, str? rounding_mode) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: divide + operator_name: divide + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide_ + operator_name: divide_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide_out + operator_name: divide + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide + operator_name: divide + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide_ + operator_name: divide_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide + operator_name: divide + overload_name: Tensor_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide.Tensor_mode(Tensor self, Tensor other, *, str? rounding_mode) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide_ + operator_name: divide_ + overload_name: Tensor_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide_.Tensor_mode(Tensor(a!) self, Tensor other, *, str? rounding_mode) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide_out + operator_name: divide + overload_name: out_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide + operator_name: divide + overload_name: Scalar_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide.Scalar_mode(Tensor self, Scalar other, *, str? rounding_mode) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: divide_ + operator_name: divide_ + overload_name: Scalar_mode + manual_kernel_registration: false + category_override: '' + schema_string: aten::divide_.Scalar_mode(Tensor(a!) self, Scalar other, *, str? rounding_mode) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: true_divide + operator_name: true_divide + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::true_divide.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: true_divide_ + operator_name: true_divide_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::true_divide_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: true_divide_out + operator_name: true_divide + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::true_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: true_divide + operator_name: true_divide + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::true_divide.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: true_divide_ + operator_name: true_divide_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::true_divide_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: dot + operator_name: dot + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::dot(Tensor self, Tensor tensor) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: dot_out + operator_name: dot + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::dot.out(Tensor self, Tensor tensor, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: vdot + operator_name: vdot + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::vdot(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: vdot_out + operator_name: vdot + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::vdot.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: einsum + operator_name: einsum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::einsum(str equation, Tensor[] tensors, *, int[]? path=None) -> Tensor + arguments: + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: equation + type: c10::string_view + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: path + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (c10::string_view, at::TensorList, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: equation + type: c10::string_view + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: path + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: embedding + operator_name: embedding + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding(Tensor weight, Tensor indices, SymInt padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: embedding_backward + operator_name: embedding_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_backward(Tensor grad, Tensor indices, SymInt num_weights, SymInt padding_idx, bool scale_grad_by_freq, bool sparse) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: embedding_dense_backward + operator_name: embedding_dense_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_dense_backward(Tensor grad_output, Tensor indices, SymInt num_weights, SymInt padding_idx, bool scale_grad_by_freq) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: embedding_renorm_ + operator_name: embedding_renorm_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_renorm_(Tensor(a!) self, Tensor indices, float max_norm, float norm_type) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: max_norm + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: norm_type + type: double + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, double, double) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: max_norm + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: norm_type + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: embedding_sparse_backward + operator_name: embedding_sparse_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_sparse_backward(Tensor grad, Tensor indices, int num_weights, int padding_idx, bool scale_grad_by_freq) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _embedding_bag_forward_only + operator_name: _embedding_bag_forward_only + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_forward_only(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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, int64_t, bool, const c10::optional &, bool, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _rowwise_prune + operator_name: _rowwise_prune + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_rowwise_prune(Tensor weight, Tensor mask, ScalarType compressed_indices_dtype) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: compressed_indices_dtype + type: at::ScalarType + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: compressed_indices_dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: row_stack + operator_name: row_stack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::row_stack(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: row_stack_out + operator_name: row_stack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::row_stack.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: embedding_bag + operator_name: embedding_bag + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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) -> (Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, int64_t, bool, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: embedding_bag + operator_name: embedding_bag + overload_name: padding_idx + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_bag.padding_idx(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq, int mode, bool sparse, Tensor? per_sample_weights, bool include_last_offset, int? padding_idx) -> (Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: padding_idx + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, int64_t, bool, const c10::optional &, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: padding_idx + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _embedding_bag + operator_name: _embedding_bag + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, int64_t, bool, const c10::optional &, bool, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _embedding_bag_backward + operator_name: _embedding_bag_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_backward(Tensor grad, Tensor indices, Tensor offsets, Tensor offset2bag, Tensor bag_size, Tensor maximum_indices, SymInt num_weights, bool scale_grad_by_freq, int mode, bool sparse, Tensor? per_sample_weights, int padding_idx=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: maximum_indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool, int64_t, bool, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: maximum_indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _embedding_bag_sparse_backward + operator_name: _embedding_bag_sparse_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_sparse_backward(Tensor grad, Tensor indices, Tensor offsets, Tensor offset2bag, Tensor bag_size, SymInt num_weights, bool scale_grad_by_freq, int mode, Tensor? per_sample_weights, int padding_idx=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool, int64_t, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _embedding_bag_dense_backward + operator_name: _embedding_bag_dense_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_dense_backward(Tensor grad, Tensor indices, Tensor offset2bag, Tensor bag_size, Tensor maximum_indices, SymInt num_weights, bool scale_grad_by_freq, int mode, Tensor? per_sample_weights, int padding_idx=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: maximum_indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool, int64_t, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: maximum_indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _embedding_bag_per_sample_weights_backward + operator_name: _embedding_bag_per_sample_weights_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_per_sample_weights_backward(Tensor grad, Tensor weight, Tensor indices, Tensor offsets, Tensor offset2bag, int mode, int padding_idx=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty + operator_name: empty + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty + operator_name: empty + overload_name: memory_format + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty.memory_format(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_permuted + operator_name: empty_permuted + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty_permuted(SymInt[] size, int[] physical_layout, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: physical_layout + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: physical_layout + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_empty + operator_name: new_empty + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_empty(Tensor self, SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_empty_strided + operator_name: new_empty_strided + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_empty_strided(Tensor self, SymInt[] size, SymInt[] stride, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_full + operator_name: new_full + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_full(Tensor self, SymInt[] size, Scalar fill_value, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_zeros + operator_name: new_zeros + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_zeros(Tensor self, SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_ones + operator_name: new_ones + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_ones(Tensor self, SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _empty_affine_quantized + operator_name: _empty_affine_quantized + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_empty_affine_quantized(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, float scale=1, int zero_point=0, MemoryFormat? memory_format=contiguous_format) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + kwarg_only: true + name: scale + type: double + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: zero_point + type: int64_t + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, double, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + kwarg_only: true + name: scale + type: double + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: zero_point + type: int64_t + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _empty_per_channel_affine_quantized + operator_name: _empty_per_channel_affine_quantized + overload_name: '' + manual_kernel_registration: false + category_override: factory + schema_string: aten::_empty_per_channel_affine_quantized(SymInt[] size, *, Tensor scales, Tensor zero_points, int axis, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=contiguous_format) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, const at::Tensor &, const at::Tensor &, int64_t, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize_ + operator_name: resize_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize_(Tensor(a!) self, SymInt[] size, *, MemoryFormat? memory_format=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: const at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _resize_output_ + operator_name: _resize_output_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_resize_output_(Tensor(a!) self, SymInt[] size, Device device) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Device) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: const at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_quantized + operator_name: empty_quantized + overload_name: '' + manual_kernel_registration: false + category_override: factory + schema_string: aten::empty_quantized(int[] size, Tensor qtensor, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qtensor + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qtensor + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_out + operator_name: empty + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty.out(SymInt[] size, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: empty_like + operator_name: empty_like + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_strided + operator_name: empty_strided + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty_strided(SymInt[] size, SymInt[] stride, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erf + operator_name: erf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::erf(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erf_ + operator_name: erf_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::erf_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erf_out + operator_name: erf + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::erf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erfc + operator_name: erfc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::erfc(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erfc_ + operator_name: erfc_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::erfc_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erfc_out + operator_name: erfc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::erfc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: exp + operator_name: exp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::exp(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: exp_ + operator_name: exp_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::exp_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: exp_out + operator_name: exp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::exp.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: exp2 + operator_name: exp2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::exp2(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: exp2_ + operator_name: exp2_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::exp2_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: exp2_out + operator_name: exp2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::exp2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: expm1 + operator_name: expm1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::expm1(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: expm1_ + operator_name: expm1_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::expm1_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: expm1_out + operator_name: expm1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::expm1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: expand + operator_name: expand + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::expand(Tensor(a) self, SymInt[] size, *, bool implicit=False) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: implicit + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: implicit + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: expand_as + operator_name: expand_as + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::expand_as(Tensor(a) self, Tensor other) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: eye + operator_name: eye + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::eye(SymInt n, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eye + operator_name: eye + overload_name: m + manual_kernel_registration: false + category_override: '' + schema_string: aten::eye.m(SymInt n, SymInt m, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: m + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: m + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eye_out + operator_name: eye + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::eye.out(SymInt n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eye_out + operator_name: eye + overload_name: m_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::eye.m_out(SymInt n, SymInt m, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: m + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: m + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: flatten + operator_name: flatten + overload_name: using_ints + manual_kernel_registration: false + category_override: '' + schema_string: aten::flatten.using_ints(Tensor(a) self, int start_dim=0, int end_dim=-1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: start_dim + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: end_dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: start_dim + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: end_dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: flatten + operator_name: flatten + overload_name: named_out_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::flatten.named_out_dim(Tensor(a) self, int start_dim, int end_dim, Dimname out_dim) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: end_dim + type: int64_t + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: out_dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, at::Dimname) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: end_dim + type: int64_t + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: out_dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: flatten + operator_name: flatten + overload_name: using_names + manual_kernel_registration: false + category_override: '' + schema_string: aten::flatten.using_names(Tensor(a) self, Dimname start_dim, Dimname end_dim, Dimname out_dim) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: start_dim + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: end_dim + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: out_dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, at::Dimname, at::Dimname) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: start_dim + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: end_dim + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: out_dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: flatten + operator_name: flatten + overload_name: DimnameList + manual_kernel_registration: false + category_override: '' + schema_string: aten::flatten.DimnameList(Tensor(a) self, Dimname[] dims, Dimname out_dim) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dims + type: at::DimnameList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: out_dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, at::Dimname) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dims + type: at::DimnameList + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: out_dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: unflatten + operator_name: unflatten + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::unflatten.int(Tensor(a) self, int dim, SymInt[] sizes) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: unflatten + operator_name: unflatten + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::unflatten.Dimname(Tensor(a) self, Dimname dim, SymInt[] sizes, Dimname[] names) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: names + type: at::DimnameList + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, at::IntArrayRef, at::DimnameList) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: names + type: at::DimnameList + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fill + operator_name: fill + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::fill.Scalar(Tensor self, Scalar value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fill + operator_name: fill + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::fill.Tensor(Tensor self, Tensor value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fill_ + operator_name: fill_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::fill_.Scalar(Tensor(a!) self, Scalar value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fill_ + operator_name: fill_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::fill_.Tensor(Tensor(a!) self, Tensor value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: floor + operator_name: floor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: floor_ + operator_name: floor_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: floor_out + operator_name: floor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: floor_divide + operator_name: floor_divide + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor_divide(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: floor_divide_ + operator_name: floor_divide_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor_divide_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: floor_divide_out + operator_name: floor_divide + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: floor_divide + operator_name: floor_divide + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor_divide.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: floor_divide_ + operator_name: floor_divide_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::floor_divide_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: frac + operator_name: frac + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::frac(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: frac_ + operator_name: frac_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::frac_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: frac_out + operator_name: frac + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::frac.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: full + operator_name: full + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::full.names(int[] size, Scalar fill_value, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: full + operator_name: full + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::full(SymInt[] size, Scalar fill_value, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: full_out + operator_name: full + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::full.out(SymInt[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: full_like + operator_name: full_like + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::full_like(Tensor self, Scalar fill_value, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: from_file + operator_name: from_file + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::from_file(str filename, bool? shared=None, int? size=0, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: filename + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: shared + type: c10::optional + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: true + name: size + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (c10::string_view, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: filename + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: shared + type: c10::optional + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: true + name: size + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gcd_out + operator_name: gcd + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::gcd.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gcd + operator_name: gcd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gcd(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gcd_ + operator_name: gcd_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gcd_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lcm_out + operator_name: lcm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lcm.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lcm + operator_name: lcm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lcm(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lcm_ + operator_name: lcm_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lcm_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: grid_sampler + operator_name: grid_sampler + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: grid_sampler_2d + operator_name: grid_sampler_2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_2d(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: grid_sampler_2d_backward + operator_name: grid_sampler_2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_2d_backward(Tensor grad_output, Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, bool[2] output_mask) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _grid_sampler_2d_cpu_fallback + operator_name: _grid_sampler_2d_cpu_fallback + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_grid_sampler_2d_cpu_fallback(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _grid_sampler_2d_cpu_fallback_backward + operator_name: _grid_sampler_2d_cpu_fallback_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_grid_sampler_2d_cpu_fallback_backward(Tensor grad_output, Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: grid_sampler_3d + operator_name: grid_sampler_3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_3d(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: grid_sampler_3d_backward + operator_name: grid_sampler_3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_3d_backward(Tensor grad_output, Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, bool[2] output_mask) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hann_window + operator_name: hann_window + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hann_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hann_window + operator_name: hann_window + overload_name: periodic + manual_kernel_registration: false + category_override: '' + schema_string: aten::hann_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window + operator_name: hamming_window + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window + operator_name: hamming_window + overload_name: periodic + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window + operator_name: hamming_window + overload_name: periodic_alpha + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window.periodic_alpha(int window_length, bool periodic, float alpha, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, double, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window + operator_name: hamming_window + overload_name: periodic_alpha_beta + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window.periodic_alpha_beta(int window_length, bool periodic, float alpha, float beta, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, double, double, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: kaiser_window + operator_name: kaiser_window + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::kaiser_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: kaiser_window + operator_name: kaiser_window + overload_name: periodic + manual_kernel_registration: false + category_override: '' + schema_string: aten::kaiser_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: kaiser_window + operator_name: kaiser_window + overload_name: beta + manual_kernel_registration: false + category_override: '' + schema_string: aten::kaiser_window.beta(int window_length, bool periodic, float beta, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, bool, double, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hinge_embedding_loss + operator_name: hinge_embedding_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hinge_embedding_loss(Tensor self, Tensor target, float margin=1.0, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: group_norm + operator_name: group_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::group_norm(Tensor input, int num_groups, Tensor? weight=None, Tensor? bias=None, float eps=1e-05, bool cudnn_enabled=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_groups + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const c10::optional &, const c10::optional &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_groups + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: native_group_norm + operator_name: native_group_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_group_norm(Tensor input, Tensor? weight, Tensor? bias, SymInt N, SymInt C, SymInt HxW, int group, float eps) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_group_norm_backward + operator_name: native_group_norm_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fft_r2c + operator_name: _fft_r2c + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fft_r2c(Tensor self, int[] dim, int normalization, bool onesided) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: onesided + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: onesided + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fft_r2c_out + operator_name: _fft_r2c + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fft_r2c.out(Tensor self, int[] dim, int normalization, bool onesided, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: onesided + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: onesided + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fft_c2r + operator_name: _fft_c2r + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fft_c2r(Tensor self, int[] dim, int normalization, SymInt last_dim_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: last_dim_size + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: last_dim_size + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fft_c2r_out + operator_name: _fft_c2r + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fft_c2r.out(Tensor self, int[] dim, int normalization, SymInt last_dim_size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: last_dim_size + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: last_dim_size + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fft_c2c + operator_name: _fft_c2c + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fft_c2c(Tensor self, SymInt[] dim, int normalization, bool forward) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: forward + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: forward + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fft_c2c_out + operator_name: _fft_c2c + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fft_c2c.out(Tensor self, SymInt[] dim, int normalization, bool forward, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: forward + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: normalization + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: forward + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _validate_compressed_sparse_indices + operator_name: _validate_compressed_sparse_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_validate_compressed_sparse_indices(bool is_crow, Tensor compressed_idx, Tensor plain_idx, int cdim, int dim, int nnz) -> () + arguments: + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_crow + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_idx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_idx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: cdim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: nnz + type: int64_t + schema_order_cpp_signature: void (bool, const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_crow + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_idx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_idx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: cdim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: nnz + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cufft_get_plan_cache_size + operator_name: _cufft_get_plan_cache_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cufft_get_plan_cache_size(DeviceIndex device_index) -> int + arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + schema_order_cpp_signature: int64_t (at::DeviceIndex) + schema_order_arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cufft_get_plan_cache_max_size + operator_name: _cufft_get_plan_cache_max_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cufft_get_plan_cache_max_size(DeviceIndex device_index) -> int + arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + schema_order_cpp_signature: int64_t (at::DeviceIndex) + schema_order_arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cufft_set_plan_cache_max_size + operator_name: _cufft_set_plan_cache_max_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cufft_set_plan_cache_max_size(DeviceIndex device_index, int max_size) -> () + arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_size + type: int64_t + schema_order_cpp_signature: void (at::DeviceIndex, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_size + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _cufft_clear_plan_cache + operator_name: _cufft_clear_plan_cache + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cufft_clear_plan_cache(DeviceIndex device_index) -> () + arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + schema_order_cpp_signature: void (at::DeviceIndex) + schema_order_arguments: + - annotation: null + dynamic_type: at::DeviceIndex + is_nullable: false + name: device_index + type: at::DeviceIndex + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index + operator_name: index + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::index.Tensor(Tensor self, Tensor?[] indices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::List> &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_out + operator_name: index + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index.Tensor_out(Tensor self, Tensor?[] indices, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::List> &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unsafe_index + operator_name: _unsafe_index + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unsafe_index.Tensor(Tensor self, Tensor?[] indices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::List> &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_copy_out + operator_name: index_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_copy.out(Tensor self, int dim, Tensor index, Tensor source, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_copy_ + operator_name: index_copy_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_copy_(Tensor(a!) self, int dim, Tensor index, Tensor source) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_copy + operator_name: index_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_copy(Tensor self, int dim, Tensor index, Tensor source) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_copy_ + operator_name: index_copy_ + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_copy_.dimname(Tensor(a!) self, Dimname dim, Tensor index, Tensor source) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Dimname, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_copy + operator_name: index_copy + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_copy.dimname(Tensor self, Dimname dim, Tensor index, Tensor source) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_put_ + operator_name: index_put_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_put_(Tensor(a!) self, Tensor?[] indices, Tensor values, bool accumulate=False) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const c10::List> &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_put + operator_name: index_put + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_put(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::List> &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unsafe_index_put + operator_name: _unsafe_index_put + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unsafe_index_put(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::List> &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _index_put_impl_ + operator_name: _index_put_impl_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_index_put_impl_(Tensor(a!) self, Tensor?[] indices, Tensor values, bool accumulate=False, bool unsafe=False) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unsafe + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const c10::List> &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unsafe + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: instance_norm + operator_name: instance_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::instance_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool use_input_stats, float momentum, float eps, bool cudnn_enabled) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: use_input_stats + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: use_input_stats + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: isclose + operator_name: isclose + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::isclose(Tensor self, Tensor other, float rtol=1e-05, float atol=1e-08, bool equal_nan=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: rtol + type: double + - annotation: null + default: 1.0e-08 + dynamic_type: double + is_nullable: false + name: atol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: equal_nan + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: rtol + type: double + - annotation: null + default: 1.0e-08 + dynamic_type: double + is_nullable: false + name: atol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: equal_nan + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: isin_out + operator_name: isin + overload_name: Tensor_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::isin.Tensor_Tensor_out(Tensor elements, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isin + operator_name: isin + overload_name: Tensor_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::isin.Tensor_Tensor(Tensor elements, Tensor test_elements, *, bool assume_unique=False, bool invert=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isin_out + operator_name: isin + overload_name: Tensor_Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::isin.Tensor_Scalar_out(Tensor elements, Scalar test_element, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: test_element + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: test_element + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isin + operator_name: isin + overload_name: Tensor_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::isin.Tensor_Scalar(Tensor elements, Scalar test_element, *, bool assume_unique=False, bool invert=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: test_element + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: elements + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: test_element + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isin_out + operator_name: isin + overload_name: Scalar_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::isin.Scalar_Tensor_out(Scalar element, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: element + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: element + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isin + operator_name: isin + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::isin.Scalar_Tensor(Scalar element, Tensor test_elements, *, bool assume_unique=False, bool invert=False) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: element + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: element + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: test_elements + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: assume_unique + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: invert + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isnan + operator_name: isnan + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::isnan(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: is_distributed + operator_name: is_distributed + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_distributed(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_floating_point + operator_name: is_floating_point + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_floating_point(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_complex + operator_name: is_complex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_complex(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_conj + operator_name: is_conj + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_conj(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: _is_zerotensor + operator_name: _is_zerotensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_is_zerotensor(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_neg + operator_name: is_neg + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_neg(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: isreal + operator_name: isreal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::isreal(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_nonzero + operator_name: is_nonzero + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_nonzero(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_same_size + operator_name: is_same_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_same_size(Tensor self, Tensor other) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: is_signed + operator_name: is_signed + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_signed(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_inference + operator_name: is_inference + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_inference(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: kl_div + operator_name: kl_div + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::kl_div(Tensor self, Tensor target, int reduction=Mean, *, bool log_target=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: log_target + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: log_target + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: kron + operator_name: kron + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::kron(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: kron_out + operator_name: kron + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::kron.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: kthvalue + operator_name: kthvalue + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::kthvalue(Tensor self, int k, int dim=-1, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: kthvalue_out + operator_name: kthvalue + overload_name: values + manual_kernel_registration: false + category_override: '' + schema_string: aten::kthvalue.values(Tensor self, int k, int dim=-1, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: kthvalue + operator_name: kthvalue + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::kthvalue.dimname(Tensor self, int k, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: kthvalue_out + operator_name: kthvalue + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::kthvalue.dimname_out(Tensor self, int k, Dimname dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: layer_norm + operator_name: layer_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::layer_norm(Tensor input, SymInt[] normalized_shape, Tensor? weight=None, Tensor? bias=None, float eps=1e-05, bool cudnn_enable=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: cudnn_enable + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, const c10::optional &, const c10::optional &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1.0e-05 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: cudnn_enable + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: native_layer_norm + operator_name: native_layer_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_layer_norm(Tensor input, SymInt[] normalized_shape, Tensor? weight, Tensor? bias, float eps) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, const c10::optional &, const c10::optional &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_layer_norm_backward + operator_name: native_layer_norm_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nan_to_num + operator_name: nan_to_num + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nan_to_num(Tensor self, float? nan=None, float? posinf=None, float? neginf=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: nan + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: posinf + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: neginf + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: nan + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: posinf + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: neginf + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nan_to_num_ + operator_name: nan_to_num_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nan_to_num_(Tensor(a!) self, float? nan=None, float? posinf=None, float? neginf=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: nan + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: posinf + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: neginf + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: nan + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: posinf + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: neginf + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nan_to_num_out + operator_name: nan_to_num + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nan_to_num.out(Tensor self, float? nan=None, float? posinf=None, float? neginf=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: nan + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: posinf + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: neginf + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: nan + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: posinf + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: neginf + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linear + operator_name: linear + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linear(Tensor input, Tensor weight, Tensor? bias=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linear_backward + operator_name: linear_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linear_backward(Tensor self, Tensor grad_output, Tensor weight, bool[3] output_mask) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linear_out + operator_name: linear + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linear.out(Tensor input, Tensor weight, Tensor? bias=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear + operator_name: mkldnn_linear + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear(Tensor self, Tensor weight, Tensor? bias=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear_backward_input + operator_name: mkldnn_linear_backward_input + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear_backward_input(int[] input_size, Tensor grad_output, Tensor weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear_backward_weights + operator_name: mkldnn_linear_backward_weights + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear_backward_weights(Tensor grad_output, Tensor input, Tensor weight, bool bias_defined) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_defined + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_defined + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear_backward + operator_name: mkldnn_linear_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear_backward(Tensor self, Tensor grad_output, Tensor weight, bool[3] output_mask) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cslt_compress + operator_name: _cslt_compress + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cslt_compress(Tensor input) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cslt_sparse_mm + operator_name: _cslt_sparse_mm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cslt_sparse_mm(Tensor compressed_A, Tensor dense_B, Tensor? bias=None, bool transpose_result=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense_B + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose_result + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense_B + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose_result + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_semi_structured_linear + operator_name: _sparse_semi_structured_linear + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_semi_structured_linear(Tensor input, Tensor weight, Tensor meta, *, Tensor? bias=None, str? activation=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: meta + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: bias + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: activation + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: meta + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: bias + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: activation + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fbgemm_linear_int8_weight_fp32_activation + operator_name: fbgemm_linear_int8_weight_fp32_activation + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_linear_int8_weight_fp32_activation(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, Scalar weight_scale, Scalar weight_zero_point, Tensor bias) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_zero_point + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_zero_point + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fbgemm_linear_int8_weight + operator_name: fbgemm_linear_int8_weight + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_linear_int8_weight(Tensor input, Tensor weight, Tensor packed, Tensor col_offsets, Scalar weight_scale, Scalar weight_zero_point, Tensor bias) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_zero_point + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight_zero_point + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fbgemm_linear_quantize_weight + operator_name: fbgemm_linear_quantize_weight + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_linear_quantize_weight(Tensor input) -> (Tensor, Tensor, float, int) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: double + name: result2 + type: double + - dynamic_type: int64_t + name: result3 + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fbgemm_pack_gemm_matrix_fp16 + operator_name: fbgemm_pack_gemm_matrix_fp16 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_pack_gemm_matrix_fp16(Tensor input) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fbgemm_linear_fp16_weight_fp32_activation + operator_name: fbgemm_linear_fp16_weight_fp32_activation + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_linear_fp16_weight_fp32_activation(Tensor input, Tensor packed_weight, Tensor bias) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fbgemm_linear_fp16_weight + operator_name: fbgemm_linear_fp16_weight + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_linear_fp16_weight(Tensor input, Tensor packed_weight, Tensor bias) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fbgemm_pack_quantized_matrix + operator_name: fbgemm_pack_quantized_matrix + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_pack_quantized_matrix(Tensor input) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fbgemm_pack_quantized_matrix + operator_name: fbgemm_pack_quantized_matrix + overload_name: KN + manual_kernel_registration: false + category_override: '' + schema_string: aten::fbgemm_pack_quantized_matrix.KN(Tensor input, int K, int N) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: K + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: K + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ldexp + operator_name: ldexp + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::ldexp.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ldexp_ + operator_name: ldexp_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ldexp_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ldexp_out + operator_name: ldexp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ldexp.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linspace + operator_name: linspace + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linspace(Scalar start, Scalar end, int steps, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Scalar &, int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linspace_out + operator_name: linspace + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linspace.out(Scalar start, Scalar end, int steps, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Scalar &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log + operator_name: log + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_ + operator_name: log_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_out + operator_name: log + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::log.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log10 + operator_name: log10 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log10(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log10_ + operator_name: log10_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log10_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log10_out + operator_name: log10 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::log10.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log1p + operator_name: log1p + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log1p(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log1p_ + operator_name: log1p_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log1p_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log1p_out + operator_name: log1p + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::log1p.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log2 + operator_name: log2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log2(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log2_ + operator_name: log2_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log2_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log2_out + operator_name: log2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::log2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logaddexp_out + operator_name: logaddexp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logaddexp.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logaddexp + operator_name: logaddexp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logaddexp(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logaddexp2_out + operator_name: logaddexp2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logaddexp2.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logaddexp2 + operator_name: logaddexp2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logaddexp2(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy + operator_name: xlogy + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy + operator_name: xlogy + overload_name: Scalar_Self + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy.Scalar_Self(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy + operator_name: xlogy + overload_name: Scalar_Other + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy.Scalar_Other(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy_ + operator_name: xlogy_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy_ + operator_name: xlogy_ + overload_name: Scalar_Other + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy_.Scalar_Other(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy_out + operator_name: xlogy + overload_name: OutTensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy.OutTensor(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy_out + operator_name: xlogy + overload_name: OutScalar_Self + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy.OutScalar_Self(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: xlogy_out + operator_name: xlogy + overload_name: OutScalar_Other + manual_kernel_registration: false + category_override: '' + schema_string: aten::xlogy.OutScalar_Other(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logspace + operator_name: logspace + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logspace(Scalar start, Scalar end, int steps, float base=10.0, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + - annotation: null + default: 10.0 + dynamic_type: double + is_nullable: false + name: base + type: double + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Scalar &, int64_t, double, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + - annotation: null + default: 10.0 + dynamic_type: double + is_nullable: false + name: base + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logspace_out + operator_name: logspace + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logspace.out(Scalar start, Scalar end, int steps, float base=10.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + - annotation: null + default: 10.0 + dynamic_type: double + is_nullable: false + name: base + type: double + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Scalar &, int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: steps + type: int64_t + - annotation: null + default: 10.0 + dynamic_type: double + is_nullable: false + name: base + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_softmax + operator_name: log_softmax + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_softmax.int(Tensor self, int dim, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: log_softmax_out + operator_name: log_softmax + overload_name: int_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_softmax.int_out(Tensor self, int dim, ScalarType? dtype=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_softmax + operator_name: log_softmax + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_softmax.Dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _log_softmax + operator_name: _log_softmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_log_softmax(Tensor self, int dim, bool half_to_float) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _log_softmax_out + operator_name: _log_softmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_log_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _log_softmax_backward_data + operator_name: _log_softmax_backward_data + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_log_softmax_backward_data(Tensor grad_output, Tensor output, int dim, ScalarType input_dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _log_softmax_backward_data_out + operator_name: _log_softmax_backward_data + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_log_softmax_backward_data.out(Tensor grad_output, Tensor output, int dim, ScalarType input_dtype, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _logcumsumexp + operator_name: _logcumsumexp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_logcumsumexp(Tensor self, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _logcumsumexp_out + operator_name: _logcumsumexp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_logcumsumexp.out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logcumsumexp + operator_name: logcumsumexp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logcumsumexp(Tensor self, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logcumsumexp_out + operator_name: logcumsumexp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logcumsumexp.out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logcumsumexp + operator_name: logcumsumexp + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::logcumsumexp.dimname(Tensor self, Dimname dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: logcumsumexp_out + operator_name: logcumsumexp + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logcumsumexp.dimname_out(Tensor self, Dimname dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: logsumexp + operator_name: logsumexp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logsumexp(Tensor self, int[1] dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logsumexp_out + operator_name: logsumexp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logsumexp.out(Tensor self, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logsumexp + operator_name: logsumexp + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::logsumexp.names(Tensor self, Dimname[1] dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: logsumexp_out + operator_name: logsumexp + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logsumexp.names_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::DimnameList, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: margin_ranking_loss + operator_name: margin_ranking_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::margin_ranking_loss(Tensor input1, Tensor input2, Tensor target, float margin=0.0, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: matmul + operator_name: matmul + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::matmul(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: matmul_backward + operator_name: matmul_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::matmul_backward(Tensor grad, Tensor self, Tensor other, bool[2] mask) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: matmul_out + operator_name: matmul + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::matmul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: matrix_power + operator_name: matrix_power + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::matrix_power(Tensor self, int n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: matrix_power_out + operator_name: matrix_power + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::matrix_power.out(Tensor self, int n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: matrix_exp + operator_name: matrix_exp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::matrix_exp(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: matrix_exp_backward + operator_name: matrix_exp_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::matrix_exp_backward(Tensor self, Tensor grad) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _aminmax + operator_name: _aminmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_aminmax(Tensor self) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _aminmax + operator_name: _aminmax + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::_aminmax.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: aminmax + operator_name: aminmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::aminmax(Tensor self, *, int? dim=None, bool keepdim=False) -> (Tensor min, Tensor max) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: min + name: min + type: at::Tensor + - dynamic_type: at::Tensor + field_name: max + name: max + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: aminmax_out + operator_name: aminmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::aminmax.out(Tensor self, *, int? dim=None, bool keepdim=False, Tensor(a!) min, Tensor(b!) max) -> (Tensor(a!) min, Tensor(b!) max) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: min + is_nullable: false + name: min + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: max + is_nullable: false + name: max + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::optional, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: min + is_nullable: false + name: min + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: max + is_nullable: false + name: max + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: min + name: min + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: max + name: max + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _compute_linear_combination + operator_name: _compute_linear_combination + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_compute_linear_combination(Tensor input, Tensor coefficients) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: coefficients + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: coefficients + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _compute_linear_combination_out + operator_name: _compute_linear_combination + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_compute_linear_combination.out(Tensor input, Tensor coefficients, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: coefficients + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: coefficients + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max + operator_name: max + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::max.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_out + operator_name: max + overload_name: dim_max + manual_kernel_registration: false + category_override: '' + schema_string: aten::max.dim_max(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) max, Tensor(b!) max_values) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: max + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: max_values + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: max + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: max_values + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: max + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: max_values + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max + operator_name: max + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::max.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: max_out + operator_name: max + overload_name: names_dim_max + manual_kernel_registration: false + category_override: '' + schema_string: aten::max.names_dim_max(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) max, Tensor(b!) max_values) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: max + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: max_values + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: max + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: max_values + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: max + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: max_values + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: value_selecting_reduction_backward + operator_name: value_selecting_reduction_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::value_selecting_reduction_backward(Tensor grad, int dim, Tensor indices, SymInt[] sizes, bool keepdim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: amax + operator_name: amax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::amax(Tensor self, int[1] dim=[], bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: amax_out + operator_name: amax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::amax.out(Tensor self, int[1] dim=[], bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool1d_with_indices + operator_name: max_pool1d_with_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool1d_with_indices(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, int[1] dilation=1, bool ceil_mode=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: max_pool1d + operator_name: max_pool1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool1d(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, int[1] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: max_pool2d + operator_name: max_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: max_pool2d_backward + operator_name: max_pool2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool2d_backward(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool2d + operator_name: mkldnn_max_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool2d_backward + operator_name: mkldnn_max_pool2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool2d_backward(Tensor grad_output, Tensor output, Tensor input, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool3d + operator_name: mkldnn_max_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool3d_backward + operator_name: mkldnn_max_pool3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool3d_backward(Tensor grad_output, Tensor output, Tensor input, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantized_max_pool1d + operator_name: quantized_max_pool1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_max_pool1d(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, int[1] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantized_max_pool2d + operator_name: quantized_max_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_max_pool2d(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantized_max_pool3d + operator_name: quantized_max_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_max_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool3d + operator_name: max_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mean + operator_name: mean + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mean(Tensor self, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mean + operator_name: mean + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::mean.dim(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mean_out + operator_name: mean + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mean.out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mean + operator_name: mean + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::mean.names_dim(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mean_out + operator_name: mean + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mean.names_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::DimnameList, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanmean + operator_name: nanmean + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmean(Tensor self, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanmean_out + operator_name: nanmean + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmean.out(Tensor self, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: median + operator_name: median + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::median(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: median + operator_name: median + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::median.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: median_out + operator_name: median + overload_name: dim_values + manual_kernel_registration: false + category_override: '' + schema_string: aten::median.dim_values(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: median + operator_name: median + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::median.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: median_out + operator_name: median + overload_name: names_dim_values + manual_kernel_registration: false + category_override: '' + schema_string: aten::median.names_dim_values(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanmedian + operator_name: nanmedian + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmedian(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nanmedian + operator_name: nanmedian + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmedian.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nanmedian_out + operator_name: nanmedian + overload_name: dim_values + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmedian.dim_values(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nanmedian + operator_name: nanmedian + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmedian.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanmedian_out + operator_name: nanmedian + overload_name: names_dim_values + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmedian.names_dim_values(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: min + operator_name: min + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::min.dim(Tensor self, int dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: min_out + operator_name: min + overload_name: dim_min + manual_kernel_registration: false + category_override: '' + schema_string: aten::min.dim_min(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: min + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: min_indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: min + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: min_indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: min + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: min_indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: min + operator_name: min + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::min.names_dim(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: min_out + operator_name: min + overload_name: names_dim_min + manual_kernel_registration: false + category_override: '' + schema_string: aten::min.names_dim_min(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: min + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: min_indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: min + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: min_indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: min + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: min_indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: amin + operator_name: amin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::amin(Tensor self, int[1] dim=[], bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: amin_out + operator_name: amin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::amin.out(Tensor self, int[1] dim=[], bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mps_convolution + operator_name: _mps_convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mps_convolution(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] stride, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mps_convolution_backward + operator_name: mps_convolution_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mps_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_convolution + operator_name: mkldnn_convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_convolution(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, int[] stride, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_rnn_layer + operator_name: mkldnn_rnn_layer + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_rnn_layer(Tensor input, Tensor weight0, Tensor weight1, Tensor weight2, Tensor weight3, Tensor hx_, Tensor cx_, bool reverse, int[] batch_sizes, int mode, int hidden_size, int num_layers, bool has_biases, bool bidirectional, bool batch_first, bool train) -> (Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight0 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_ + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, at::IntArrayRef, int64_t, int64_t, int64_t, bool, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight0 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_ + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_rnn_layer_backward + operator_name: mkldnn_rnn_layer_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_rnn_layer_backward(Tensor input, Tensor weight1, Tensor weight2, Tensor weight3, Tensor weight4, Tensor hx_, Tensor cx_tmp, Tensor output, Tensor hy_, Tensor cy_, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, bool reverse, int mode, int hidden_size, int num_layers, bool has_biases, bool train, bool bidirectional, int[] batch_sizes, bool batch_first, Tensor workspace) -> (Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight4 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_tmp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, int64_t, int64_t, int64_t, bool, bool, bool, at::IntArrayRef, bool, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight4 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_tmp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + - dynamic_type: at::Tensor + name: result5 + type: at::Tensor + - dynamic_type: at::Tensor + name: result6 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_batch_norm + operator_name: miopen_batch_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_batch_norm_backward + operator_name: miopen_batch_norm_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_batch_norm_backward(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, float epsilon) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_convolution + operator_name: miopen_convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_convolution(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_convolution_transpose + operator_name: miopen_convolution_transpose + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_convolution_transpose(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, SymInt[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_depthwise_convolution + operator_name: miopen_depthwise_convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_depthwise_convolution(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_convolution_relu + operator_name: miopen_convolution_relu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_convolution_relu(Tensor self, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_convolution_add_relu + operator_name: miopen_convolution_add_relu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_convolution_add_relu(Tensor self, Tensor weight, Tensor z, Scalar? alpha, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: alpha + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: alpha + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_rnn + operator_name: miopen_rnn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_rnn(Tensor input, Tensor[] weight, int weight_stride0, Tensor hx, Tensor? cx, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state) -> (Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, int64_t, const at::Tensor &, const c10::optional &, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_rnn_backward + operator_name: miopen_rnn_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_rnn_backward(Tensor input, Tensor[] weight, int weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state, Tensor reserve, bool[4] output_mask) -> (Tensor, Tensor, Tensor, Tensor[]) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple> (const at::Tensor &, at::TensorList, int64_t, const at::Tensor &, const at::Tensor &, const c10::optional &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &, const at::Tensor &, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::TensorList + name: result3 + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mm + operator_name: mm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mm(Tensor self, Tensor mat2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mm_out + operator_name: mm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _int_mm + operator_name: _int_mm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_int_mm(Tensor self, Tensor mat2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _int_mm_out + operator_name: _int_mm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_int_mm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_mm + operator_name: _sparse_mm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_mm(Tensor sparse, Tensor dense) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sparse + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sparse + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_mm + operator_name: _sparse_mm + overload_name: reduce + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_mm.reduce(Tensor sparse, Tensor dense, str reduce) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sparse + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sparse + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_sparse_matmul + operator_name: _sparse_sparse_matmul + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sparse_matmul(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mode + operator_name: mode + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mode(Tensor self, int dim=-1, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mode_out + operator_name: mode + overload_name: values + manual_kernel_registration: false + category_override: '' + schema_string: aten::mode.values(Tensor self, int dim=-1, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mode + operator_name: mode + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::mode.dimname(Tensor self, Dimname dim, bool keepdim=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mode_out + operator_name: mode + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mode.dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mul + operator_name: mul + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::mul.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mul_ + operator_name: mul_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::mul_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mul_out + operator_name: mul + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mul + operator_name: mul + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::mul.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mul_ + operator_name: mul_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::mul_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multiply + operator_name: multiply + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::multiply.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: multiply_ + operator_name: multiply_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::multiply_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: multiply_out + operator_name: multiply + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::multiply.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: multiply + operator_name: multiply + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::multiply.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: multiply_ + operator_name: multiply_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::multiply_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mv + operator_name: mv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mv(Tensor self, Tensor vec) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mv_out + operator_name: mv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mv.out(Tensor self, Tensor vec, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mvlgamma_out + operator_name: mvlgamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mvlgamma.out(Tensor self, int p, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mvlgamma + operator_name: mvlgamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mvlgamma(Tensor self, int p) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mvlgamma_ + operator_name: mvlgamma_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mvlgamma_(Tensor(a!) self, int p) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: narrow_copy + operator_name: narrow_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::narrow_copy(Tensor self, int dim, SymInt start, SymInt length) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: narrow_copy_out + operator_name: narrow_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::narrow_copy.out(Tensor self, int dim, SymInt start, SymInt length, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: narrow + operator_name: narrow + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::narrow(Tensor(a) self, int dim, SymInt start, SymInt length) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: narrow + operator_name: narrow + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::narrow.Tensor(Tensor(a) self, int dim, Tensor start, SymInt length) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: start + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: start + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: length + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: native_batch_norm + operator_name: native_batch_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_batch_norm_out + operator_name: native_batch_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_batch_norm.out(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: save_mean + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: save_invstd + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: save_mean + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: save_invstd + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: save_mean + type: at::Tensor & + - dynamic_type: at::Tensor + name: save_invstd + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_batch_norm_legit + operator_name: _native_batch_norm_legit + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &, at::Tensor &, bool, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_batch_norm_legit_no_training + operator_name: _native_batch_norm_legit_no_training + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_batch_norm_legit_out + operator_name: _native_batch_norm_legit + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_native_batch_norm_legit.out(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps, *, Tensor(d!) out, Tensor(e!) save_mean, Tensor(f!) save_invstd) -> (Tensor(d!), Tensor(e!), Tensor(f!)) + arguments: + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: save_mean + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: save_invstd + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &, at::Tensor &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: save_mean + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: save_invstd + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: save_mean + type: at::Tensor & + - dynamic_type: at::Tensor + name: save_invstd + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_batch_norm_legit + operator_name: _native_batch_norm_legit + overload_name: no_stats + manual_kernel_registration: false + category_override: '' + schema_string: aten::_native_batch_norm_legit.no_stats(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, bool, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_batch_norm_legit_out + operator_name: _native_batch_norm_legit + overload_name: no_stats_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_native_batch_norm_legit.no_stats_out(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: save_mean + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: save_invstd + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: save_mean + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: save_invstd + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: save_mean + type: at::Tensor & + - dynamic_type: at::Tensor + name: save_invstd + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_stats + operator_name: batch_norm_stats + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_stats(Tensor input, float eps) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_elemt + operator_name: batch_norm_elemt + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_elemt(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor invstd, float eps) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_elemt_out + operator_name: batch_norm_elemt + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_elemt.out(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor invstd, float eps, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_gather_stats + operator_name: batch_norm_gather_stats + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_gather_stats(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, int count) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: count + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, double, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: count + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_gather_stats_with_counts + operator_name: batch_norm_gather_stats_with_counts + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_gather_stats_with_counts(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, Tensor counts) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: counts + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, double, double, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: counts + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_batch_norm_backward + operator_name: native_batch_norm_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_batch_norm_backward(Tensor grad_out, Tensor input, Tensor? weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_invstd, bool train, float eps, bool[3] output_mask) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_invstd + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_invstd + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_backward_reduce + operator_name: batch_norm_backward_reduce + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_backward_reduce(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, Tensor? weight, bool input_g, bool weight_g, bool bias_g) -> (Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: input_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: weight_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_g + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: input_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: weight_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_g + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_backward_elemt + operator_name: batch_norm_backward_elemt + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_backward_elemt(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, Tensor? weight, Tensor sum_dy, Tensor sum_dy_xmu, Tensor count) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy_xmu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy_xmu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_update_stats + operator_name: batch_norm_update_stats + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_update_stats(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: is_vulkan_available + operator_name: is_vulkan_available + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_vulkan_available() -> bool + arguments: [] + schema_order_cpp_signature: bool () + schema_order_arguments: [] + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _nnpack_available + operator_name: _nnpack_available + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nnpack_available() -> bool + arguments: [] + schema_order_cpp_signature: bool () + schema_order_arguments: [] + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _nnpack_spatial_convolution + operator_name: _nnpack_spatial_convolution + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nnpack_spatial_convolution(Tensor input, Tensor weight, Tensor? bias, SymInt[2] padding, int[2] stride=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ones + operator_name: ones + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::ones.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: ones + operator_name: ones + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ones(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ones_out + operator_name: ones + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ones.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ones_like + operator_name: ones_like + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ones_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pairwise_distance + operator_name: pairwise_distance + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pairwise_distance(Tensor x1, Tensor x2, float p=2, float eps=1e-06, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: 1.0e-06 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: 1.0e-06 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cdist + operator_name: cdist + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cdist(Tensor x1, Tensor x2, float p=2, int? compute_mode=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: compute_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: compute_mode + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _euclidean_dist + operator_name: _euclidean_dist + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_euclidean_dist(Tensor x1, Tensor x2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cdist_forward + operator_name: _cdist_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cdist_forward(Tensor x1, Tensor x2, float p, int? compute_mode) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: compute_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: compute_mode + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cdist_backward + operator_name: _cdist_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cdist_backward(Tensor grad, Tensor x1, Tensor x2, float p, Tensor cdist) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cdist + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cdist + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pdist + operator_name: pdist + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pdist(Tensor self, float p=2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _pdist_forward + operator_name: _pdist_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pdist_forward(Tensor self, float p=2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _pdist_backward + operator_name: _pdist_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pdist_backward(Tensor grad, Tensor self, float p, Tensor pdist) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pdist + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pdist + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cosine_similarity + operator_name: cosine_similarity + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cosine_similarity(Tensor x1, Tensor x2, int dim=1, float eps=1e-08) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: 1.0e-08 + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: 1.0e-08 + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: permute + operator_name: permute + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::permute(Tensor(a) self, int[] dims) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: movedim + operator_name: movedim + overload_name: intlist + manual_kernel_registration: false + category_override: '' + schema_string: aten::movedim.intlist(Tensor(a) self, int[] source, int[] destination) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: source + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: destination + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: source + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: destination + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: movedim + operator_name: movedim + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::movedim.int(Tensor(a) self, int source, int destination) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: source + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: destination + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: source + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: destination + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: moveaxis + operator_name: moveaxis + overload_name: intlist + manual_kernel_registration: false + category_override: '' + schema_string: aten::moveaxis.intlist(Tensor(a) self, int[] source, int[] destination) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: source + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: destination + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: source + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: destination + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: moveaxis + operator_name: moveaxis + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::moveaxis.int(Tensor(a) self, int source, int destination) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: source + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: destination + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: source + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: destination + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: numpy_T + operator_name: numpy_T + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::numpy_T(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: matrix_H + operator_name: matrix_H + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::matrix_H(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mT + operator_name: mT + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mT(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mH + operator_name: mH + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mH(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: adjoint + operator_name: adjoint + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adjoint(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: pixel_shuffle + operator_name: pixel_shuffle + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pixel_shuffle(Tensor self, int upscale_factor) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: upscale_factor + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: upscale_factor + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pixel_unshuffle + operator_name: pixel_unshuffle + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pixel_unshuffle(Tensor self, int downscale_factor) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: downscale_factor + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: downscale_factor + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: channel_shuffle + operator_name: channel_shuffle + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::channel_shuffle(Tensor self, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_channel_shuffle + operator_name: native_channel_shuffle + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_channel_shuffle(Tensor self, int groups) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: is_pinned + operator_name: is_pinned + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_pinned(Tensor self, Device? device=None) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + schema_order_cpp_signature: bool (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pin_memory + operator_name: pin_memory + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pin_memory(Tensor(a) self, Device? device=None) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _pin_memory + operator_name: _pin_memory + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pin_memory(Tensor self, Device? device=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pinverse + operator_name: pinverse + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pinverse(Tensor self, float rcond=1e-15) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1.0e-15 + dynamic_type: double + is_nullable: false + name: rcond + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1.0e-15 + dynamic_type: double + is_nullable: false + name: rcond + type: double + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: poisson_nll_loss + operator_name: poisson_nll_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::poisson_nll_loss(Tensor input, Tensor target, bool log_input, bool full, float eps, int reduction) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: log_input + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: full + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: log_input + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: full + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rad2deg + operator_name: rad2deg + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rad2deg(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rad2deg_ + operator_name: rad2deg_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rad2deg_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rad2deg_out + operator_name: rad2deg + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rad2deg.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: deg2rad + operator_name: deg2rad + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::deg2rad(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: deg2rad_ + operator_name: deg2rad_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::deg2rad_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: deg2rad_out + operator_name: deg2rad + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::deg2rad.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scalar_tensor + operator_name: scalar_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::scalar_tensor(Scalar s, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: s + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: s + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand + operator_name: rand + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand.names(SymInt[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand + operator_name: rand + overload_name: generator_with_names + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand.generator_with_names(SymInt[] size, *, Generator? generator, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand + operator_name: rand + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand + operator_name: rand + overload_name: generator + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand.generator(SymInt[] size, *, Generator? generator, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand_out + operator_name: rand + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand_out + operator_name: rand + overload_name: generator_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand.generator_out(SymInt[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rand_like + operator_name: rand_like + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint + operator_name: randint + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint(SymInt high, SymInt[] size, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint + operator_name: randint + overload_name: generator + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint.generator(SymInt high, SymInt[] size, *, Generator? generator, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint + operator_name: randint + overload_name: low + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint.low(SymInt low, SymInt high, SymInt[] size, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, int64_t, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint + operator_name: randint + overload_name: low_generator + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint.low_generator(SymInt low, SymInt high, SymInt[] size, *, Generator? generator, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, int64_t, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_out + operator_name: randint + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint.out(SymInt high, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (int64_t, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_out + operator_name: randint + overload_name: generator_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint.generator_out(SymInt high, SymInt[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (int64_t, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_out + operator_name: randint + overload_name: low_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint.low_out(SymInt low, SymInt high, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (int64_t, int64_t, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_out + operator_name: randint + overload_name: low_generator_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint.low_generator_out(SymInt low, SymInt high, SymInt[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (int64_t, int64_t, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_like + operator_name: randint_like + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint_like(Tensor self, SymInt high, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_like + operator_name: randint_like + overload_name: low_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint_like.low_dtype(Tensor self, SymInt low, SymInt high, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn + operator_name: randn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn + operator_name: randn + overload_name: generator + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn.generator(SymInt[] size, *, Generator? generator, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn + operator_name: randn + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn.names(SymInt[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn + operator_name: randn + overload_name: generator_with_names + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn.generator_with_names(SymInt[] size, *, Generator? generator, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn_out + operator_name: randn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: randn_out + operator_name: randn + overload_name: generator_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn.generator_out(SymInt[] size, *, Generator? generator, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: randn_like + operator_name: randn_like + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randperm + operator_name: randperm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::randperm(SymInt n, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randperm + operator_name: randperm + overload_name: generator + manual_kernel_registration: false + category_override: '' + schema_string: aten::randperm.generator(SymInt n, *, Generator? generator, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randperm_out + operator_name: randperm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randperm.out(SymInt n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: randperm_out + operator_name: randperm + overload_name: generator_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randperm.generator_out(SymInt n, *, Generator? generator, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: range + operator_name: range + overload_name: step + manual_kernel_registration: false + category_override: '' + schema_string: aten::range.step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Scalar &, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: range + operator_name: range + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::range(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Scalar &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: range_out + operator_name: range + overload_name: out_ + manual_kernel_registration: false + category_override: '' + schema_string: aten::range.out_(Scalar start, Scalar end, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: range_out + operator_name: range + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::range.out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: start + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: end + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: step + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ravel + operator_name: ravel + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ravel(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: reciprocal + operator_name: reciprocal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reciprocal(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reciprocal_ + operator_name: reciprocal_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reciprocal_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reciprocal_out + operator_name: reciprocal + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::reciprocal.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: neg + operator_name: neg + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::neg(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: neg_ + operator_name: neg_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::neg_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: neg_out + operator_name: neg + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::neg.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: negative + operator_name: negative + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::negative(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: negative_ + operator_name: negative_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::negative_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: negative_out + operator_name: negative + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::negative.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: repeat + operator_name: repeat + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::repeat(Tensor self, SymInt[] repeats) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: repeats + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: repeats + type: at::IntArrayRef + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: repeat_interleave + operator_name: repeat_interleave + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::repeat_interleave.Tensor(Tensor repeats, *, int? output_size=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: repeats + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: repeats + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: repeat_interleave + operator_name: repeat_interleave + overload_name: self_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::repeat_interleave.self_Tensor(Tensor self, Tensor repeats, int? dim=None, *, int? output_size=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: repeats + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: repeats + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: repeat_interleave + operator_name: repeat_interleave + overload_name: self_int + manual_kernel_registration: false + category_override: '' + schema_string: aten::repeat_interleave.self_int(Tensor self, SymInt repeats, int? dim=None, *, int? output_size=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: repeats + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: repeats + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: reshape + operator_name: reshape + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reshape(Tensor(a) self, SymInt[] shape) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: _reshape_copy + operator_name: _reshape_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_reshape_copy(Tensor self, SymInt[] size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _reshape_alias + operator_name: _reshape_alias + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_reshape_alias(Tensor(a) self, SymInt[] size, SymInt[] stride) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mkldnn_reshape + operator_name: _mkldnn_reshape + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mkldnn_reshape(Tensor self, int[] shape) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: reshape_as + operator_name: reshape_as + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reshape_as(Tensor(a) self, Tensor other) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: round + operator_name: round + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::round(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: round_ + operator_name: round_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::round_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: round_out + operator_name: round + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::round.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: round + operator_name: round + overload_name: decimals + manual_kernel_registration: false + category_override: '' + schema_string: aten::round.decimals(Tensor self, *, int decimals) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: round_ + operator_name: round_ + overload_name: decimals + manual_kernel_registration: false + category_override: '' + schema_string: aten::round_.decimals(Tensor(a!) self, *, int decimals) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: round_out + operator_name: round + overload_name: decimals_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::round.decimals_out(Tensor self, *, int decimals, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rrelu + operator_name: rrelu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rrelu(Tensor self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rrelu_ + operator_name: rrelu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rrelu_(Tensor(a!) self, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &, bool, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: relu + operator_name: relu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::relu(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: relu_ + operator_name: relu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::relu_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: relu6 + operator_name: relu6 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::relu6(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: relu6_ + operator_name: relu6_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::relu6_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: prelu + operator_name: prelu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::prelu(Tensor self, Tensor weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _prelu_kernel + operator_name: _prelu_kernel + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_prelu_kernel(Tensor self, Tensor weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _prelu_kernel_backward + operator_name: _prelu_kernel_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_prelu_kernel_backward(Tensor grad_output, Tensor self, Tensor weight) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gelu_out + operator_name: gelu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::gelu.out(Tensor self, *, str approximate='none', Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gelu_ + operator_name: gelu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gelu_(Tensor(a!) self, *, str approximate='none') -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gelu + operator_name: gelu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gelu(Tensor self, *, str approximate='none') -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gelu_backward_out + operator_name: gelu_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::gelu_backward.grad_input(Tensor grad_output, Tensor self, *, str approximate='none', Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gelu_backward + operator_name: gelu_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gelu_backward(Tensor grad_output, Tensor self, *, str approximate='none') -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"none"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: approximate + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: infinitely_differentiable_gelu_backward + operator_name: infinitely_differentiable_gelu_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::infinitely_differentiable_gelu_backward(Tensor grad, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: hardshrink_out + operator_name: hardshrink + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardshrink.out(Tensor self, Scalar lambd=0.5, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardshrink + operator_name: hardshrink + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardshrink(Tensor self, Scalar lambd=0.5) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardshrink_backward_out + operator_name: hardshrink_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardshrink_backward.grad_input(Tensor grad_out, Tensor self, Scalar lambd, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardshrink_backward + operator_name: hardshrink_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardshrink_backward(Tensor grad_out, Tensor self, Scalar lambd) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rsqrt + operator_name: rsqrt + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rsqrt(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rsqrt_ + operator_name: rsqrt_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rsqrt_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rsqrt_out + operator_name: rsqrt + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rsqrt.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: select + operator_name: select + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::select.Dimname(Tensor(a) self, Dimname dim, int index) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: select + operator_name: select + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::select.int(Tensor(a) self, int dim, SymInt index) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: select_backward + operator_name: select_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::select_backward(Tensor grad_output, SymInt[] input_sizes, int dim, SymInt index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_select_backward + operator_name: _nested_select_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_select_backward(Tensor grad_output, Tensor self, int dim, SymInt index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: selu + operator_name: selu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::selu(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: selu_ + operator_name: selu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::selu_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: celu + operator_name: celu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::celu(Tensor self, Scalar alpha=1.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: celu_ + operator_name: celu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::celu_(Tensor(a!) self, Scalar alpha=1.0) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: silu + operator_name: silu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::silu(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: silu_ + operator_name: silu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::silu_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: silu_out + operator_name: silu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::silu.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: silu_backward_out + operator_name: silu_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::silu_backward.grad_input(Tensor grad_output, Tensor self, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: silu_backward + operator_name: silu_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::silu_backward(Tensor grad_output, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mish + operator_name: mish + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mish(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mish_ + operator_name: mish_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mish_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mish_out + operator_name: mish + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mish.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mish_backward + operator_name: mish_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mish_backward(Tensor grad_output, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sigmoid + operator_name: sigmoid + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sigmoid(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sigmoid_ + operator_name: sigmoid_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sigmoid_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sigmoid_out + operator_name: sigmoid + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logit + operator_name: logit + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logit(Tensor self, float? eps=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logit_ + operator_name: logit_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logit_(Tensor(a!) self, float? eps=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logit_out + operator_name: logit + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::logit.out(Tensor self, float? eps=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sin + operator_name: sin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sin(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sin_ + operator_name: sin_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sin_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sin_out + operator_name: sin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sinc + operator_name: sinc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sinc(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sinc_ + operator_name: sinc_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sinc_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sinc_out + operator_name: sinc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sinc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sinh + operator_name: sinh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sinh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sinh_ + operator_name: sinh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sinh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sinh_out + operator_name: sinh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: detach + operator_name: detach + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::detach(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: detach_ + operator_name: detach_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::detach_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: size + operator_name: size + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::size.int(Tensor self, int dim) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: int64_t (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: size + operator_name: size + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::size.Dimname(Tensor self, Dimname dim) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: int64_t (const at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: sym_size + operator_name: sym_size + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::sym_size.int(Tensor self, int dim) -> SymInt + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: c10::SymInt (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: c10::SymInt + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: sym_numel + operator_name: sym_numel + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sym_numel(Tensor self) -> SymInt + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: c10::SymInt (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: c10::SymInt + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: sym_storage_offset + operator_name: sym_storage_offset + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sym_storage_offset(Tensor self) -> SymInt + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: c10::SymInt (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: c10::SymInt + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: slice + operator_name: slice + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::slice.Tensor(Tensor(a) self, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: slice_backward + operator_name: slice_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slice_backward(Tensor grad_output, SymInt[] input_sizes, int dim, SymInt start, SymInt end, SymInt step) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: end + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: end + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: slice_scatter + operator_name: slice_scatter + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slice_scatter(Tensor self, Tensor src, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, c10::optional, c10::optional, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: select_scatter + operator_name: select_scatter + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::select_scatter(Tensor self, Tensor src, int dim, SymInt index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: diagonal_scatter + operator_name: diagonal_scatter + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal_scatter(Tensor self, Tensor src, int offset=0, int dim1=0, int dim2=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: as_strided_scatter + operator_name: as_strided_scatter + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::as_strided_scatter(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: smm + operator_name: smm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::smm(Tensor self, Tensor mat2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: softmax + operator_name: softmax + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::softmax.int(Tensor self, int dim, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: softmax_out + operator_name: softmax + overload_name: int_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::softmax.int_out(Tensor self, int dim, ScalarType? dtype=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softmax + operator_name: softmax + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::softmax.Dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _softmax + operator_name: _softmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_softmax(Tensor self, int dim, bool half_to_float) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _softmax_out + operator_name: _softmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _softmax_backward_data + operator_name: _softmax_backward_data + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_softmax_backward_data(Tensor grad_output, Tensor output, int dim, ScalarType input_dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _softmax_backward_data_out + operator_name: _softmax_backward_data + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_softmax_backward_data.out(Tensor grad_output, Tensor output, int dim, ScalarType input_dtype, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: input_dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unsafe_split + operator_name: unsafe_split + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsafe_split.Tensor(Tensor self, SymInt split_size, int dim=0) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: split + operator_name: split + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::split.Tensor(Tensor(a -> *) self, SymInt split_size, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: split + operator_name: split + overload_name: sizes + manual_kernel_registration: false + category_override: '' + schema_string: aten::split.sizes(Tensor(a -> *) self, SymInt[] split_size, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_size + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_size + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: unsafe_split_with_sizes + operator_name: unsafe_split_with_sizes + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsafe_split_with_sizes(Tensor self, SymInt[] split_sizes, int dim=0) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: split_with_sizes + operator_name: split_with_sizes + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::split_with_sizes(Tensor(a -> *) self, SymInt[] split_sizes, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hsplit + operator_name: hsplit + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::hsplit.int(Tensor(a -> *) self, int sections) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: hsplit + operator_name: hsplit + overload_name: array + manual_kernel_registration: false + category_override: '' + schema_string: aten::hsplit.array(Tensor(a -> *) self, int[] indices) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: vsplit + operator_name: vsplit + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::vsplit.int(Tensor(a -> *) self, int sections) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: vsplit + operator_name: vsplit + overload_name: array + manual_kernel_registration: false + category_override: '' + schema_string: aten::vsplit.array(Tensor(a -> *) self, int[] indices) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: dsplit + operator_name: dsplit + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::dsplit.int(Tensor(a -> *) self, int sections) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sections + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: dsplit + operator_name: dsplit + overload_name: array + manual_kernel_registration: false + category_override: '' + schema_string: aten::dsplit.array(Tensor(a -> *) self, int[] indices) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: indices + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: squeeze + operator_name: squeeze + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze + operator_name: squeeze + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze.dim(Tensor(a) self, int dim) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze + operator_name: squeeze + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze.dimname(Tensor(a) self, Dimname dim) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: squeeze + operator_name: squeeze + overload_name: dims + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze.dims(Tensor(a) self, int[] dim) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_ + operator_name: squeeze_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_ + operator_name: squeeze_ + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_.dim(Tensor(a!) self, int dim) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_ + operator_name: squeeze_ + overload_name: dims + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_.dims(Tensor(a!) self, int[] dim) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_ + operator_name: squeeze_ + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_.dimname(Tensor(a!) self, Dimname dim) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: sspaddmm + operator_name: sspaddmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sspaddmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sspaddmm_out + operator_name: sspaddmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sspaddmm.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: stack + operator_name: stack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::stack(Tensor[] tensors, int dim=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (at::TensorList, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: stack_out + operator_name: stack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::stack.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::TensorList, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _stack + operator_name: _stack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_stack(Tensor[] tensors, int dim=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (at::TensorList, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _stack_out + operator_name: _stack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_stack.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::TensorList, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hstack + operator_name: hstack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hstack(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: hstack_out + operator_name: hstack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hstack.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: vstack + operator_name: vstack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::vstack(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: vstack_out + operator_name: vstack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::vstack.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: dstack + operator_name: dstack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::dstack(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: dstack_out + operator_name: dstack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::dstack.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: stft + operator_name: stft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::stft(Tensor self, int n_fft, int? hop_length=None, int? win_length=None, Tensor? window=None, bool normalized=False, bool? onesided=None, bool? return_complex=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_fft + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: hop_length + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: win_length + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: window + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: normalized + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: onesided + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: return_complex + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional, const c10::optional &, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_fft + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: hop_length + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: win_length + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: window + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: normalized + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: onesided + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: return_complex + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: stft + operator_name: stft + overload_name: center + manual_kernel_registration: false + category_override: '' + schema_string: aten::stft.center(Tensor self, int n_fft, int? hop_length=None, int? win_length=None, Tensor? window=None, bool center=True, str pad_mode="reflect", bool normalized=False, bool? onesided=None, bool? return_complex=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_fft + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: hop_length + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: win_length + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: window + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: center + type: bool + - annotation: null + default: '"reflect"' + dynamic_type: c10::string_view + is_nullable: false + name: pad_mode + type: c10::string_view + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: normalized + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: onesided + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: return_complex + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional, const c10::optional &, bool, c10::string_view, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_fft + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: hop_length + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: win_length + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: window + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: center + type: bool + - annotation: null + default: '"reflect"' + dynamic_type: c10::string_view + is_nullable: false + name: pad_mode + type: c10::string_view + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: normalized + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: onesided + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: return_complex + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: istft + operator_name: istft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::istft(Tensor self, int n_fft, int? hop_length=None, int? win_length=None, Tensor? window=None, bool center=True, bool normalized=False, bool? onesided=None, int? length=None, bool return_complex=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_fft + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: hop_length + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: win_length + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: window + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: center + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: normalized + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: onesided + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: length + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_complex + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional, const c10::optional &, bool, bool, c10::optional, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_fft + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: hop_length + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: win_length + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: window + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: center + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: normalized + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: onesided + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: length + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_complex + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: stride + operator_name: stride + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::stride.int(Tensor self, int dim) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: int64_t (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: stride + operator_name: stride + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::stride.Dimname(Tensor self, Dimname dim) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: int64_t (const at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: sym_stride + operator_name: sym_stride + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::sym_stride.int(Tensor self, int dim) -> SymInt + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: c10::SymInt (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: c10::SymInt + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: sum + operator_name: sum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sum(Tensor self, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sum + operator_name: sum + overload_name: dim_IntList + manual_kernel_registration: false + category_override: '' + schema_string: aten::sum.dim_IntList(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sum + operator_name: sum + overload_name: dim_DimnameList + manual_kernel_registration: false + category_override: '' + schema_string: aten::sum.dim_DimnameList(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sum_out + operator_name: sum + overload_name: IntList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sum.IntList_out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sum_out + operator_name: sum + overload_name: DimnameList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sum.DimnameList_out(Tensor self, Dimname[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::DimnameList, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _nested_sum_backward + operator_name: _nested_sum_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_sum_backward(Tensor grad, Tensor self, int[1]? dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::OptionalIntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nansum + operator_name: nansum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nansum(Tensor self, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nansum_out + operator_name: nansum + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nansum.out(Tensor self, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sum_to_size + operator_name: sum_to_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sum_to_size(Tensor self, SymInt[] size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: sqrt + operator_name: sqrt + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sqrt(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sqrt_ + operator_name: sqrt_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sqrt_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sqrt_out + operator_name: sqrt + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sqrt.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: square + operator_name: square + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::square(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: square_ + operator_name: square_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::square_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: square_out + operator_name: square + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::square.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std + operator_name: std + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::std(Tensor self, bool unbiased=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std + operator_name: std + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.dim(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std + operator_name: std + overload_name: correction + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.correction(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: std_mean + operator_name: std_mean + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::std_mean(Tensor self, bool unbiased=True) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std_mean + operator_name: std_mean + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::std_mean.dim(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::OptionalIntArrayRef, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std_mean + operator_name: std_mean + overload_name: correction + manual_kernel_registration: false + category_override: '' + schema_string: aten::std_mean.correction(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: std_mean + operator_name: std_mean + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::std_mean.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::DimnameList, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std_mean + operator_name: std_mean + overload_name: correction_names + manual_kernel_registration: false + category_override: '' + schema_string: aten::std_mean.correction_names(Tensor self, Dimname[1] dim, *, Scalar? correction=None, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::DimnameList, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std_out + operator_name: std + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.out(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std_out + operator_name: std + overload_name: correction_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.correction_out(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: std + operator_name: std + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std_out + operator_name: std + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.names_out(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::DimnameList, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std + operator_name: std + overload_name: correction_names + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.correction_names(Tensor self, Dimname[1] dim, *, Scalar? correction=None, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: std_out + operator_name: std + overload_name: correction_names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::std.correction_names_out(Tensor self, Dimname[1] dim, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::DimnameList, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: prod + operator_name: prod + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::prod(Tensor self, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: prod + operator_name: prod + overload_name: dim_int + manual_kernel_registration: false + category_override: '' + schema_string: aten::prod.dim_int(Tensor self, int dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: prod_out + operator_name: prod + overload_name: int_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::prod.int_out(Tensor self, int dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: prod + operator_name: prod + overload_name: dim_Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::prod.dim_Dimname(Tensor self, Dimname dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: prod_out + operator_name: prod + overload_name: Dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::prod.Dimname_out(Tensor self, Dimname dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: t + operator_name: t + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::t(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: t_ + operator_name: t_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::t_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: tan + operator_name: tan + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tan(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tan_ + operator_name: tan_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tan_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tan_out + operator_name: tan + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::tan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tanh + operator_name: tanh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tanh(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tanh_ + operator_name: tanh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tanh_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tanh_out + operator_name: tanh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::tanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tensordot + operator_name: tensordot + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tensordot(Tensor self, Tensor other, int[] dims_self, int[] dims_other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_self + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_other + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_self + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_other + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: tensordot_out + operator_name: tensordot + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::tensordot.out(Tensor self, Tensor other, int[] dims_self, int[] dims_other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_self + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_other + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_self + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims_other + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: threshold + operator_name: threshold + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::threshold(Tensor self, Scalar threshold, Scalar value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: threshold_ + operator_name: threshold_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::threshold_(Tensor(a!) self, Scalar threshold, Scalar value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: threshold_out + operator_name: threshold + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::threshold.out(Tensor self, Scalar threshold, Scalar value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: threshold_backward_out + operator_name: threshold_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::threshold_backward.grad_input(Tensor grad_output, Tensor self, Scalar threshold, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: threshold_backward + operator_name: threshold_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::threshold_backward(Tensor grad_output, Tensor self, Scalar threshold) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tile + operator_name: tile + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tile(Tensor self, SymInt[] dims) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: transpose + operator_name: transpose + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::transpose.int(Tensor(a) self, int dim0, int dim1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: transpose + operator_name: transpose + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::transpose.Dimname(Tensor(a) self, Dimname dim0, Dimname dim1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim0 + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim1 + type: at::Dimname + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, at::Dimname) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim0 + type: at::Dimname + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim1 + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: _mkldnn_transpose + operator_name: _mkldnn_transpose + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mkldnn_transpose(Tensor self, int dim0, int dim1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: transpose_ + operator_name: transpose_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::transpose_(Tensor(a!) self, int dim0, int dim1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mkldnn_transpose_ + operator_name: _mkldnn_transpose_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mkldnn_transpose_(Tensor(a!) self, int dim0, int dim1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: one_hot + operator_name: one_hot + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::one_hot(Tensor self, int num_classes=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: num_classes + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: num_classes + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: flip + operator_name: flip + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::flip(Tensor self, int[] dims) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fliplr + operator_name: fliplr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fliplr(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: flipud + operator_name: flipud + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::flipud(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: roll + operator_name: roll + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::roll(Tensor self, SymInt[1] shifts, int[1] dims=[]) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shifts + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + size: 1 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shifts + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + size: 1 + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rot90 + operator_name: rot90 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rot90(Tensor self, int k=1, int[] dims=[0,1]) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: '{0,1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: '{0,1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: trapezoid + operator_name: trapezoid + overload_name: x + manual_kernel_registration: false + category_override: '' + schema_string: aten::trapezoid.x(Tensor y, Tensor x, *, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: trapezoid + operator_name: trapezoid + overload_name: dx + manual_kernel_registration: false + category_override: '' + schema_string: aten::trapezoid.dx(Tensor y, *, Scalar dx=1, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: dx + type: const at::Scalar & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: dx + type: const at::Scalar & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: trapz + operator_name: trapz + overload_name: x + manual_kernel_registration: false + category_override: '' + schema_string: aten::trapz.x(Tensor y, Tensor x, *, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: trapz + operator_name: trapz + overload_name: dx + manual_kernel_registration: false + category_override: '' + schema_string: aten::trapz.dx(Tensor y, *, float dx=1, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + kwarg_only: true + name: dx + type: double + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + kwarg_only: true + name: dx + type: double + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _transform_bias_rescale_qkv + operator_name: _transform_bias_rescale_qkv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_transform_bias_rescale_qkv(Tensor qkv, Tensor qkv_bias, int num_heads) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_from_mask + operator_name: _nested_tensor_from_mask + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_from_mask(Tensor t, Tensor mask, bool mask_check=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: t + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: mask_check + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: t + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: mask_check + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_from_mask_left_aligned + operator_name: _nested_tensor_from_mask_left_aligned + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_from_mask_left_aligned(Tensor t, Tensor mask) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: t + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: t + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_from_padded + operator_name: _nested_from_padded + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_from_padded(Tensor padded, Tensor cpu_nested_shape_example, bool fuse_transform_0213=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cpu_nested_shape_example + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: fuse_transform_0213 + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cpu_nested_shape_example + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: fuse_transform_0213 + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_size + operator_name: _nested_tensor_size + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_size(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_strides + operator_name: _nested_tensor_strides + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_strides(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_storage_offsets + operator_name: _nested_tensor_storage_offsets + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_storage_offsets(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_from_padded_and_nested_example + operator_name: _nested_from_padded_and_nested_example + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_from_padded_and_nested_example(Tensor padded, Tensor nt_example) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nt_example + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nt_example + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_view_from_buffer + operator_name: _nested_view_from_buffer + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_view_from_buffer(Tensor(a) self, Tensor nested_size, Tensor nested_strides, Tensor offsets) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_strides + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_strides + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_view_from_buffer_copy + operator_name: _nested_view_from_buffer_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_view_from_buffer_copy(Tensor self, Tensor nested_size, Tensor nested_strides, Tensor offsets) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_strides + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_strides + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _trilinear + operator_name: _trilinear + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_trilinear(Tensor i1, Tensor i2, Tensor i3, int[] expand1, int[] expand2, int[] expand3, int[] sumdim, int unroll_dim=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sumdim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: unroll_dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sumdim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: unroll_dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: triplet_margin_loss + operator_name: triplet_margin_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::triplet_margin_loss(Tensor anchor, Tensor positive, Tensor negative, float margin=1.0, float p=2, float eps=1e-06, bool swap=False, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: anchor + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: positive + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: negative + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: 1.0e-06 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: swap + type: bool + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, double, double, bool, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: anchor + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: positive + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: negative + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: margin + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: 1.0e-06 + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: swap + type: bool + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: trunc + operator_name: trunc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::trunc(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: trunc_ + operator_name: trunc_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::trunc_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: trunc_out + operator_name: trunc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::trunc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fix + operator_name: fix + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fix(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fix_ + operator_name: fix_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fix_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fix_out + operator_name: fix + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fix.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: type_as + operator_name: type_as + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::type_as(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _has_compatible_shallow_copy_type + operator_name: _has_compatible_shallow_copy_type + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_has_compatible_shallow_copy_type(Tensor self, Tensor from) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: from + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: from + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _unique + operator_name: _unique + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unique(Tensor self, bool sorted=True, bool return_inverse=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unique_dim + operator_name: unique_dim + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unique_dim(Tensor self, int dim, bool sorted=True, bool return_inverse=False, bool return_counts=False) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unique_consecutive + operator_name: unique_consecutive + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unique_consecutive(Tensor self, bool return_inverse=False, bool return_counts=False, int? dim=None) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unique_dim_consecutive + operator_name: unique_dim_consecutive + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unique_dim_consecutive(Tensor self, int dim, bool return_inverse=False, bool return_counts=False) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unique2 + operator_name: _unique2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unique2(Tensor self, bool sorted=True, bool return_inverse=False, bool return_counts=False) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unsafe_view + operator_name: _unsafe_view + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unsafe_view(Tensor self, SymInt[] size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unsqueeze + operator_name: unsqueeze + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsqueeze(Tensor(a) self, int dim) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unsqueeze_ + operator_name: unsqueeze_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsqueeze_(Tensor(a!) self, int dim) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: vander + operator_name: vander + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::vander(Tensor x, int? N=None, bool increasing=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: N + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: increasing + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: N + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: increasing + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var + operator_name: var + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::var(Tensor self, bool unbiased=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var + operator_name: var + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.dim(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var + operator_name: var + overload_name: correction + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.correction(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: var_out + operator_name: var + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.out(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var_out + operator_name: var + overload_name: correction_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.correction_out(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: var + operator_name: var + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var_out + operator_name: var + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.names_out(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::DimnameList, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var + operator_name: var + overload_name: correction_names + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.correction_names(Tensor self, Dimname[1] dim, *, Scalar? correction=None, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::DimnameList, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var_out + operator_name: var + overload_name: correction_names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::var.correction_names_out(Tensor self, Dimname[1] dim, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::DimnameList, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var_mean + operator_name: var_mean + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::var_mean(Tensor self, bool unbiased=True) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var_mean + operator_name: var_mean + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::var_mean.dim(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::OptionalIntArrayRef, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var_mean + operator_name: var_mean + overload_name: correction + manual_kernel_registration: false + category_override: '' + schema_string: aten::var_mean.correction(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: var_mean + operator_name: var_mean + overload_name: names_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::var_mean.names_dim(Tensor self, Dimname[1] dim, bool unbiased=True, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::DimnameList, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unbiased + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: var_mean + operator_name: var_mean + overload_name: correction_names + manual_kernel_registration: false + category_override: '' + schema_string: aten::var_mean.correction_names(Tensor self, Dimname[1] dim, *, Scalar? correction=None, bool keepdim=False) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::DimnameList, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: view_as + operator_name: view_as + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_as(Tensor(a) self, Tensor other) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: where + operator_name: where + overload_name: self + manual_kernel_registration: false + category_override: '' + schema_string: aten::where.self(Tensor condition, Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: where_out + operator_name: where + overload_name: self_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::where.self_out(Tensor condition, Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: where + operator_name: where + overload_name: ScalarSelf + manual_kernel_registration: false + category_override: '' + schema_string: aten::where.ScalarSelf(Tensor condition, Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: where + operator_name: where + overload_name: ScalarOther + manual_kernel_registration: false + category_override: '' + schema_string: aten::where.ScalarOther(Tensor condition, Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: where + operator_name: where + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::where.Scalar(Tensor condition, Scalar self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: where + operator_name: where + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::where(Tensor condition) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + schema_order_cpp_signature: ::std::vector (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: condition + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: norm_except_dim + operator_name: norm_except_dim + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm_except_dim(Tensor v, int pow=2, int dim=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: pow + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: pow + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _weight_norm + operator_name: _weight_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_weight_norm(Tensor v, Tensor g, int dim=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: g + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: g + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _weight_norm_interface + operator_name: _weight_norm_interface + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_weight_norm_interface(Tensor v, Tensor g, int dim=0) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: g + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: g + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _weight_norm_interface_backward + operator_name: _weight_norm_interface_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_weight_norm_interface_backward(Tensor grad_w, Tensor saved_v, Tensor saved_g, Tensor saved_norms, int dim) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_w + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_g + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_norms + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_w + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_g + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_norms + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _weight_norm_differentiable_backward + operator_name: _weight_norm_differentiable_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_weight_norm_differentiable_backward(Tensor grad_w, Tensor saved_v, Tensor saved_g, Tensor saved_norms, int dim) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_w + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_g + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_norms + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_w + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_g + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_norms + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: zeros + operator_name: zeros + overload_name: names + manual_kernel_registration: false + category_override: '' + schema_string: aten::zeros.names(int[] size, *, Dimname[]? names, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _efficientzerotensor + operator_name: _efficientzerotensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_efficientzerotensor(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: zeros + operator_name: zeros + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::zeros(SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: zeros_out + operator_name: zeros + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::zeros.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: zeros_like + operator_name: zeros_like + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::zeros_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _standard_gamma_grad + operator_name: _standard_gamma_grad + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_standard_gamma_grad(Tensor self, Tensor output) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _standard_gamma + operator_name: _standard_gamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_standard_gamma(Tensor self, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _dirichlet_grad + operator_name: _dirichlet_grad + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_dirichlet_grad(Tensor x, Tensor alpha, Tensor total) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: alpha + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: alpha + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sample_dirichlet + operator_name: _sample_dirichlet + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sample_dirichlet(Tensor self, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: poisson + operator_name: poisson + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::poisson(Tensor self, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: binomial + operator_name: binomial + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::binomial(Tensor count, Tensor prob, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: prob + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: prob + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_norm + operator_name: native_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_norm(Tensor self, Scalar p=2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_norm + operator_name: native_norm + overload_name: ScalarOpt_dim_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_norm.ScalarOpt_dim_dtype(Tensor self, Scalar? p, int[1] dim, bool keepdim, ScalarType? dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, at::IntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_sum + operator_name: _sparse_sum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sum(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_sum + operator_name: _sparse_sum + overload_name: dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sum.dtype(Tensor self, *, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_sum + operator_name: _sparse_sum + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sum.dim(Tensor self, int[1] dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_sum + operator_name: _sparse_sum + overload_name: dim_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sum.dim_dtype(Tensor self, int[1] dim, *, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_sum_backward + operator_name: _sparse_sum_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sum_backward(Tensor grad, Tensor self, int[] dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_csr_sum + operator_name: _sparse_csr_sum + overload_name: dim_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_csr_sum.dim_dtype(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_csr_prod + operator_name: _sparse_csr_prod + overload_name: dim_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_csr_prod.dim_dtype(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_softmax + operator_name: _sparse_softmax + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_softmax.int(Tensor self, int dim, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_softmax + operator_name: _sparse_softmax + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_softmax.Dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_softmax + operator_name: _sparse_softmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_softmax(Tensor self, int dim, bool half_to_float) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_softmax_backward_data + operator_name: _sparse_softmax_backward_data + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_softmax_backward_data(Tensor grad_output, Tensor output, int dim, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_log_softmax + operator_name: _sparse_log_softmax + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_log_softmax.int(Tensor self, int dim, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_log_softmax + operator_name: _sparse_log_softmax + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_log_softmax.Dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_log_softmax + operator_name: _sparse_log_softmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_log_softmax(Tensor self, int dim, bool half_to_float) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_log_softmax_backward_data + operator_name: _sparse_log_softmax_backward_data + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_log_softmax_backward_data(Tensor grad_output, Tensor output, int dim, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _spdiags + operator_name: _spdiags + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_spdiags(Tensor diagonals, Tensor offsets, int[] shape, Layout? layout=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: diagonals + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: diagonals + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm + operator_name: norm + overload_name: ScalarOpt_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.ScalarOpt_dtype(Tensor self, Scalar? p, *, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm + operator_name: norm + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.Scalar(Tensor self, Scalar p=2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm + operator_name: norm + overload_name: ScalarOpt_dim_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.ScalarOpt_dim_dtype(Tensor self, Scalar? p, int[1] dim, bool keepdim, *, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, at::IntArrayRef, bool, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm + operator_name: norm + overload_name: ScalarOpt_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.ScalarOpt_dim(Tensor self, Scalar? p, int[1] dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm_out + operator_name: norm + overload_name: dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.dtype_out(Tensor self, Scalar? p, int[1] dim, bool keepdim, *, ScalarType dtype, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::IntArrayRef, bool, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm_out + operator_name: norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.out(Tensor self, Scalar? p, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm + operator_name: norm + overload_name: names_ScalarOpt_dim_dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.names_ScalarOpt_dim_dtype(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim, *, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, at::DimnameList, bool, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: norm + operator_name: norm + overload_name: names_ScalarOpt_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.names_ScalarOpt_dim(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, at::DimnameList, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: norm_out + operator_name: norm + overload_name: names_dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.names_dtype_out(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim, *, ScalarType dtype, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::DimnameList, bool, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: norm_out + operator_name: norm + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.names_out(Tensor self, Scalar? p, Dimname[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::DimnameList, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: false + name: dim + size: 1 + type: at::DimnameList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: frexp + operator_name: frexp + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::frexp.Tensor(Tensor self) -> (Tensor mantissa, Tensor exponent) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: mantissa + name: mantissa + type: at::Tensor + - dynamic_type: at::Tensor + field_name: exponent + name: exponent + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: frexp_out + operator_name: frexp + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::frexp.Tensor_out(Tensor self, *, Tensor(a!) mantissa, Tensor(b!) exponent) -> (Tensor(a!) mantissa, Tensor(b!) exponent) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: mantissa + is_nullable: false + name: mantissa + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: exponent + is_nullable: false + name: exponent + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: mantissa + is_nullable: false + name: mantissa + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: exponent + is_nullable: false + name: exponent + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: mantissa + name: mantissa + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: exponent + name: exponent + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: frobenius_norm + operator_name: frobenius_norm + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::frobenius_norm.dim(Tensor self, int[1] dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: frobenius_norm_out + operator_name: frobenius_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::frobenius_norm.out(Tensor self, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nuclear_norm + operator_name: nuclear_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nuclear_norm(Tensor self, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nuclear_norm_out + operator_name: nuclear_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nuclear_norm.out(Tensor self, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nuclear_norm + operator_name: nuclear_norm + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::nuclear_norm.dim(Tensor self, int[2] dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nuclear_norm_out + operator_name: nuclear_norm + overload_name: dim_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nuclear_norm.dim_out(Tensor self, int[2] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: clone + operator_name: clone + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::clone(Tensor self, *, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: positive + operator_name: positive + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::positive(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: resize_as_ + operator_name: resize_as_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize_as_(Tensor(a!) self, Tensor the_template, *, MemoryFormat? memory_format=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: const at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize_as_sparse_ + operator_name: resize_as_sparse_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize_as_sparse_(Tensor(a!) self, Tensor the_template) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: const at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: zero_ + operator_name: zero_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::zero_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sub_out + operator_name: sub + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sub.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sub + operator_name: sub + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::sub.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sub_ + operator_name: sub_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::sub_.Tensor(Tensor(a!) self, Tensor other, *, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sub + operator_name: sub + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::sub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sub_ + operator_name: sub_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::sub_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: subtract_out + operator_name: subtract + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::subtract.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: subtract + operator_name: subtract + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::subtract.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: subtract_ + operator_name: subtract_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::subtract_.Tensor(Tensor(a!) self, Tensor other, *, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: subtract + operator_name: subtract + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::subtract.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: subtract_ + operator_name: subtract_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::subtract_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rsub + operator_name: rsub + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::rsub.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: heaviside_out + operator_name: heaviside + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::heaviside.out(Tensor self, Tensor values, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: heaviside + operator_name: heaviside + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::heaviside(Tensor self, Tensor values) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: heaviside_ + operator_name: heaviside_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::heaviside_(Tensor(a!) self, Tensor values) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rsub + operator_name: rsub + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::rsub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_addmm + operator_name: _sparse_addmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_addmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_sampled_addmm_out + operator_name: sparse_sampled_addmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_sampled_addmm.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_sampled_addmm + operator_name: sparse_sampled_addmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_sampled_addmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_mm_reduce_impl + operator_name: _sparse_mm_reduce_impl + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_mm_reduce_impl(Tensor self, Tensor other, str reduce) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_mm_reduce_impl_backward + operator_name: _sparse_mm_reduce_impl_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_mm_reduce_impl_backward(Tensor self, Tensor grad_out, Tensor weight, str reduce, Tensor arg_out, bool[2] output_mask) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: arg_out + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::string_view, const at::Tensor &, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: arg_out + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: sparse + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addmm_out + operator_name: addmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::addmm.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addmm + operator_name: addmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addmm(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addmm_ + operator_name: addmm_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addmm_(Tensor(a!) self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _addmm_activation_out + operator_name: _addmm_activation + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_addmm_activation.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, bool use_gelu=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: use_gelu + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: use_gelu + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _addmm_activation + operator_name: _addmm_activation + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_addmm_activation(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, bool use_gelu=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: use_gelu + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: use_gelu + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _scaled_mm + operator_name: _scaled_mm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_scaled_mm(Tensor self, Tensor mat2, *, Tensor? bias=None, ScalarType? out_dtype=None, Tensor? scale_a=None, Tensor? scale_b=None, Tensor? scale_result=None) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: bias + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: out_dtype + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_a + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_b + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_result + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, c10::optional, const c10::optional &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: bias + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: out_dtype + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_a + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_b + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_result + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _scaled_mm_out + operator_name: _scaled_mm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_scaled_mm.out(Tensor self, Tensor mat2, *, Tensor? bias=None, ScalarType? out_dtype=None, Tensor? scale_a=None, Tensor? scale_b=None, Tensor? scale_result=None, Tensor(a!) out, Tensor(b!) out_amax) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out_amax + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: bias + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: out_dtype + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_a + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_b + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_result + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, c10::optional, const c10::optional &, const c10::optional &, const c10::optional &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: bias + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: out_dtype + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_a + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_b + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: scale_result + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out_amax + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: out_amax + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_compressed_tensor + operator_name: sparse_compressed_tensor + overload_name: comp_plain_value_size + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_compressed_tensor.comp_plain_value_size(Tensor compressed_indices, Tensor plain_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_csr_tensor + operator_name: sparse_csr_tensor + overload_name: crow_col_value_size + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_csr_tensor.crow_col_value_size(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_csc_tensor + operator_name: sparse_csc_tensor + overload_name: ccol_row_value_size + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_csc_tensor.ccol_row_value_size(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_bsr_tensor + operator_name: sparse_bsr_tensor + overload_name: crow_col_value_size + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_bsr_tensor.crow_col_value_size(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_bsc_tensor + operator_name: sparse_bsc_tensor + overload_name: ccol_row_value_size + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_bsc_tensor.ccol_row_value_size(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_compressed_tensor + operator_name: sparse_compressed_tensor + overload_name: comp_plain_value + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_compressed_tensor.comp_plain_value(Tensor compressed_indices, Tensor plain_indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_csr_tensor + operator_name: sparse_csr_tensor + overload_name: crow_col_value + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_csr_tensor.crow_col_value(Tensor crow_indices, Tensor col_indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_csc_tensor + operator_name: sparse_csc_tensor + overload_name: ccol_row_value + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_csc_tensor.ccol_row_value(Tensor ccol_indices, Tensor row_indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_bsr_tensor + operator_name: sparse_bsr_tensor + overload_name: crow_col_value + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_bsr_tensor.crow_col_value(Tensor crow_indices, Tensor col_indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_bsc_tensor + operator_name: sparse_bsc_tensor + overload_name: ccol_row_value + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_bsc_tensor.ccol_row_value(Tensor ccol_indices, Tensor row_indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_compressed_tensor_unsafe + operator_name: _sparse_compressed_tensor_unsafe + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_compressed_tensor_unsafe(Tensor compressed_indices, Tensor plain_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_csr_tensor_unsafe + operator_name: _sparse_csr_tensor_unsafe + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_csr_tensor_unsafe(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_csc_tensor_unsafe + operator_name: _sparse_csc_tensor_unsafe + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_csc_tensor_unsafe(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_bsr_tensor_unsafe + operator_name: _sparse_bsr_tensor_unsafe + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_bsr_tensor_unsafe(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_bsc_tensor_unsafe + operator_name: _sparse_bsc_tensor_unsafe + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_bsc_tensor_unsafe(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_coo_tensor + operator_name: sparse_coo_tensor + overload_name: size + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_coo_tensor.size(int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_coo_tensor + operator_name: sparse_coo_tensor + overload_name: indices + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_coo_tensor.indices(Tensor indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, bool? is_coalesced=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_coo_tensor + operator_name: sparse_coo_tensor + overload_name: indices_size + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_coo_tensor.indices_size(Tensor indices, Tensor values, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, bool? is_coalesced=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_coo_tensor_unsafe + operator_name: _sparse_coo_tensor_unsafe + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_coo_tensor_unsafe(Tensor indices, Tensor values, SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, bool? is_coalesced=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _validate_sparse_coo_tensor_args + operator_name: _validate_sparse_coo_tensor_args + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_validate_sparse_coo_tensor_args(Tensor indices, Tensor values, int[] size, bool? is_coalesced=None) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: is_coalesced + type: c10::optional + schema_order_cpp_signature: void (const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: is_coalesced + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _validate_sparse_compressed_tensor_args + operator_name: _validate_sparse_compressed_tensor_args + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_validate_sparse_compressed_tensor_args(Tensor compressed_indices, Tensor plain_indices, Tensor values, int[] size, Layout layout) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Layout + is_nullable: false + name: layout + type: at::Layout + schema_order_cpp_signature: void (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Layout) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: compressed_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: plain_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Layout + is_nullable: false + name: layout + type: at::Layout + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _validate_sparse_csr_tensor_args + operator_name: _validate_sparse_csr_tensor_args + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_validate_sparse_csr_tensor_args(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: void (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _validate_sparse_csc_tensor_args + operator_name: _validate_sparse_csc_tensor_args + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_validate_sparse_csc_tensor_args(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: void (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _validate_sparse_bsr_tensor_args + operator_name: _validate_sparse_bsr_tensor_args + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_validate_sparse_bsr_tensor_args(Tensor crow_indices, Tensor col_indices, Tensor values, int[] size) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: void (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _validate_sparse_bsc_tensor_args + operator_name: _validate_sparse_bsc_tensor_args + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_validate_sparse_bsc_tensor_args(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: void (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ccol_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: row_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _sparse_coo_tensor_with_dims + operator_name: _sparse_coo_tensor_with_dims + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_coo_tensor_with_dims(int sparse_dim, int dense_dim, int[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, int64_t, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_coo_tensor_with_dims_and_tensors + operator_name: _sparse_coo_tensor_with_dims_and_tensors + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_coo_tensor_with_dims_and_tensors(int sparse_dim, int dense_dim, SymInt[] size, Tensor indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False, bool? is_coalesced=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + schema_order_cpp_signature: at::Tensor (int64_t, int64_t, at::IntArrayRef, const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_resize_ + operator_name: sparse_resize_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_resize_(Tensor(a!) self, int[] size, int sparse_dim, int dense_dim) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: const at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_resize_and_clear_ + operator_name: sparse_resize_and_clear_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_resize_and_clear_(Tensor(a!) self, int[] size, int sparse_dim, int dense_dim) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: const at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_mask + operator_name: sparse_mask + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_mask(Tensor self, Tensor mask) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_mask_projection + operator_name: _sparse_mask_projection + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_mask_projection(Tensor self, Tensor mask, bool accumulate_matches=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate_matches + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate_matches + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_cpu + operator_name: _to_cpu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_cpu(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: to_dense + operator_name: to_dense + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_dense(Tensor self, ScalarType? dtype=None, *, bool? masked_grad=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: masked_grad + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: masked_grad + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_dense + operator_name: _to_dense + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_dense(Tensor self, ScalarType? dtype=None, bool? masked_grad=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: masked_grad + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: masked_grad + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_dense_backward + operator_name: to_dense_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_dense_backward(Tensor grad, Tensor input, bool? masked_grad=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: masked_grad + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: masked_grad + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sparse_dim + operator_name: sparse_dim + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_dim(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _dimI + operator_name: _dimI + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_dimI(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: dense_dim + operator_name: dense_dim + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::dense_dim(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _dimV + operator_name: _dimV + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_dimV(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nnz + operator_name: _nnz + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nnz(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: coalesce + operator_name: coalesce + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::coalesce(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _coalesce + operator_name: _coalesce + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_coalesce(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: is_coalesced + operator_name: is_coalesced + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_coalesced(Tensor self) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _indices + operator_name: _indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_indices(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _values + operator_name: _values + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_values(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _coalesced_ + operator_name: _coalesced_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_coalesced_(Tensor(a!) self, bool coalesced) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: coalesced + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: coalesced + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: indices + operator_name: indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::indices(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: values + operator_name: values + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::values(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: crow_indices + operator_name: crow_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::crow_indices(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: col_indices + operator_name: col_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::col_indices(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: ccol_indices + operator_name: ccol_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ccol_indices(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: row_indices + operator_name: row_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::row_indices(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hspmm_out + operator_name: hspmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hspmm.out(Tensor mat1, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hspmm + operator_name: hspmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hspmm(Tensor mat1, Tensor mat2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: copy_sparse_to_sparse_ + operator_name: copy_sparse_to_sparse_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::copy_sparse_to_sparse_(Tensor(a!) self, Tensor src, bool non_blocking=False) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unbind + operator_name: unbind + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::unbind.int(Tensor(a -> *) self, int dim=0) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unbind + operator_name: unbind + overload_name: Dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::unbind.Dimname(Tensor(a -> *) self, Dimname dim) -> Tensor(a)[] + arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::Dimname) + schema_order_arguments: + - annotation: a -> * + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: to_sparse + operator_name: to_sparse + overload_name: sparse_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_sparse.sparse_dim(Tensor self, int sparse_dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_sparse + operator_name: _to_sparse + overload_name: sparse_dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse.sparse_dim(Tensor self, int sparse_dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_sparse + operator_name: to_sparse + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_sparse(Tensor self, *, Layout? layout=None, int[2]? blocksize=None, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: blocksize + size: 2 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: blocksize + size: 2 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_sparse + operator_name: _to_sparse + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse(Tensor self, *, Layout? layout=None, int[2]? blocksize=None, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: blocksize + size: 2 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: blocksize + size: 2 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_sparse_csr + operator_name: to_sparse_csr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_sparse_csr(Tensor self, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_sparse_csr + operator_name: _to_sparse_csr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_csr(Tensor self, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_sparse_csc + operator_name: to_sparse_csc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_sparse_csc(Tensor self, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_sparse_csc + operator_name: _to_sparse_csc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_csc(Tensor self, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_sparse_bsr + operator_name: to_sparse_bsr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_sparse_bsr(Tensor self, int[2] blocksize, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_sparse_bsr + operator_name: _to_sparse_bsr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_bsr(Tensor self, int[2] blocksize, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_sparse_bsc + operator_name: to_sparse_bsc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_sparse_bsc(Tensor self, int[2] blocksize, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_sparse_bsc + operator_name: _to_sparse_bsc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_bsc(Tensor self, int[2] blocksize, int? dense_dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_sparse_semi_structured + operator_name: _to_sparse_semi_structured + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_semi_structured(Tensor dense) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dense + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_mkldnn + operator_name: to_mkldnn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_mkldnn(Tensor self, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_reorder_conv2d_weight + operator_name: mkldnn_reorder_conv2d_weight + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_reorder_conv2d_weight(Tensor self, int[2] padding=0, int[2] stride=1, int[2] dilation=1, int groups=1, int[]? input_size=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: input_size + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: input_size + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_reorder_conv3d_weight + operator_name: mkldnn_reorder_conv3d_weight + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_reorder_conv3d_weight(Tensor self, int[3] padding=0, int[3] stride=1, int[3] dilation=1, int groups=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_mkldnn_backward + operator_name: to_mkldnn_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_mkldnn_backward(Tensor grad, Tensor input) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantize_per_tensor_dynamic + operator_name: quantize_per_tensor_dynamic + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor_dynamic(Tensor self, ScalarType dtype, bool reduce_range) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + dynamic_type: bool + is_nullable: false + name: reduce_range + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::ScalarType, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + dynamic_type: bool + is_nullable: false + name: reduce_range + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_tensor + operator_name: quantize_per_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor(Tensor self, float scale, int zero_point, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, int64_t, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_tensor + operator_name: quantize_per_tensor + overload_name: tensor_qparams + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor.tensor_qparams(Tensor self, Tensor scale, Tensor zero_point, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_tensor + operator_name: quantize_per_tensor + overload_name: tensors + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor.tensors(Tensor[] tensors, Tensor scales, Tensor zero_points, ScalarType dtype) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Tensor &, const at::Tensor &, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_channel + operator_name: quantize_per_channel + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_channel(Tensor self, Tensor scales, Tensor zero_points, int axis, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: dequantize + operator_name: dequantize + overload_name: self + manual_kernel_registration: false + category_override: '' + schema_string: aten::dequantize.self(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: dequantize + operator_name: dequantize + overload_name: tensors + manual_kernel_registration: false + category_override: '' + schema_string: aten::dequantize.tensors(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: q_scale + operator_name: q_scale + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::q_scale(Tensor self) -> float + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: double (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: double + name: result + type: double + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: q_zero_point + operator_name: q_zero_point + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::q_zero_point(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: q_per_channel_scales + operator_name: q_per_channel_scales + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::q_per_channel_scales(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: q_per_channel_zero_points + operator_name: q_per_channel_zero_points + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::q_per_channel_zero_points(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: q_per_channel_axis + operator_name: q_per_channel_axis + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::q_per_channel_axis(Tensor self) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: int64_t (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: int_repr + operator_name: int_repr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::int_repr(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_per_tensor_quantized_tensor + operator_name: _make_per_tensor_quantized_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_per_tensor_quantized_tensor(Tensor self, float scale, int zero_point) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_per_channel_quantized_tensor + operator_name: _make_per_channel_quantized_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_per_channel_quantized_tensor(Tensor self, Tensor scale, Tensor zero_point, int axis) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: qscheme + operator_name: qscheme + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::qscheme(Tensor self) -> QScheme + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::QScheme (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::QScheme + name: result + type: at::QScheme + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fake_quantize_per_tensor_affine + operator_name: fake_quantize_per_tensor_affine + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_tensor_affine(Tensor self, float scale, int zero_point, int quant_min, int quant_max) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fake_quantize_per_tensor_affine + operator_name: fake_quantize_per_tensor_affine + overload_name: tensor_qparams + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_tensor_affine.tensor_qparams(Tensor self, Tensor scale, Tensor zero_point, int quant_min, int quant_max) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fake_quantize_per_tensor_affine_cachemask + operator_name: fake_quantize_per_tensor_affine_cachemask + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_tensor_affine_cachemask(Tensor self, float scale, int zero_point, int quant_min, int quant_max) -> (Tensor output, Tensor mask) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: mask + name: mask + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fake_quantize_per_tensor_affine_cachemask_tensor_qparams + operator_name: _fake_quantize_per_tensor_affine_cachemask_tensor_qparams + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams(Tensor self, Tensor scale, Tensor zero_point, Tensor fake_quant_enabled, int quant_min, int quant_max) -> (Tensor output, Tensor mask) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_enabled + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_enabled + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: mask + name: mask + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fake_quantize_per_tensor_affine_cachemask_backward + operator_name: fake_quantize_per_tensor_affine_cachemask_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_tensor_affine_cachemask_backward(Tensor grad, Tensor mask) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _fake_quantize_learnable_per_tensor_affine + operator_name: _fake_quantize_learnable_per_tensor_affine + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_learnable_per_tensor_affine(Tensor self, Tensor scale, Tensor zero_point, int quant_min, int quant_max, float grad_factor=1.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fake_quantize_learnable_per_tensor_affine_backward + operator_name: _fake_quantize_learnable_per_tensor_affine_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_learnable_per_tensor_affine_backward(Tensor grad, Tensor self, Tensor scale, Tensor zero_point, int quant_min, int quant_max, float grad_factor=1.0) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fake_quantize_per_channel_affine + operator_name: fake_quantize_per_channel_affine + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_channel_affine(Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fake_quantize_per_channel_affine_cachemask + operator_name: fake_quantize_per_channel_affine_cachemask + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_channel_affine_cachemask(Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max) -> (Tensor output, Tensor mask) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: mask + name: mask + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fake_quantize_per_channel_affine_cachemask_backward + operator_name: fake_quantize_per_channel_affine_cachemask_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_channel_affine_cachemask_backward(Tensor grad, Tensor mask) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _fake_quantize_learnable_per_channel_affine + operator_name: _fake_quantize_learnable_per_channel_affine + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_learnable_per_channel_affine(Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max, float grad_factor=1.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fake_quantize_learnable_per_channel_affine_backward + operator_name: _fake_quantize_learnable_per_channel_affine_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_learnable_per_channel_affine_backward(Tensor grad, Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max, float grad_factor=1.0) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fused_moving_avg_obs_fake_quant + operator_name: fused_moving_avg_obs_fake_quant + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fused_moving_avg_obs_fake_quant(Tensor self, Tensor observer_on, Tensor fake_quant_on, Tensor(a!) running_min, Tensor(b!) running_max, Tensor(c!) scale, Tensor(d!) zero_point, float averaging_const, int quant_min, int quant_max, int ch_axis, bool per_row_fake_quant=False, bool symmetric_quant=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: at::Tensor & + - annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: at::Tensor & + - annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, double, int64_t, int64_t, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: at::Tensor & + - annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: at::Tensor & + - annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _fused_moving_avg_obs_fq_helper + operator_name: _fused_moving_avg_obs_fq_helper + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_moving_avg_obs_fq_helper(Tensor self, Tensor observer_on, Tensor fake_quant_on, Tensor(a!) running_min, Tensor(b!) running_max, Tensor(c!) scale, Tensor(d!) zero_point, float averaging_const, int quant_min, int quant_max, int ch_axis, bool per_row_fake_quant=False, bool symmetric_quant=False) -> (Tensor output, Tensor mask) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: at::Tensor & + - annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: at::Tensor & + - annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, double, int64_t, int64_t, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: at::Tensor & + - annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: at::Tensor & + - annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: mask + name: mask + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _choose_qparams_per_tensor + operator_name: _choose_qparams_per_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_choose_qparams_per_tensor(Tensor self, bool reduce_range=False) -> (float, int) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: reduce_range + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: reduce_range + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: double + name: result0 + type: double + - dynamic_type: int64_t + name: result1 + type: int64_t + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _saturate_weight_to_fp16 + operator_name: _saturate_weight_to_fp16 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_saturate_weight_to_fp16(Tensor weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: choose_qparams_optimized + operator_name: choose_qparams_optimized + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::choose_qparams_optimized(Tensor input, int numel, int n_bins, float ratio, int bit_width) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: numel + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_bins + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: ratio + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: bit_width + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, int64_t, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: numel + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n_bins + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: ratio + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: bit_width + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _autocast_to_reduced_precision + operator_name: _autocast_to_reduced_precision + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_autocast_to_reduced_precision(Tensor(a) self, bool cuda_enabled, bool cpu_enabled, ScalarType cuda_dtype, ScalarType cpu_dtype) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: cuda_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cpu_enabled + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: cuda_dtype + type: at::ScalarType + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: cpu_dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool, bool, at::ScalarType, at::ScalarType) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: cuda_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cpu_enabled + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: cuda_dtype + type: at::ScalarType + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: cpu_dtype + type: at::ScalarType + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: _autocast_to_full_precision + operator_name: _autocast_to_full_precision + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_autocast_to_full_precision(Tensor(a) self, bool cuda_enabled, bool cpu_enabled) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: cuda_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cpu_enabled + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: cuda_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cpu_enabled + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: _to_copy + operator_name: _to_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_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 + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: non_blocking + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: non_blocking + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: to + operator_name: to + overload_name: dtype_layout + manual_kernel_registration: false + category_override: '' + schema_string: aten::to.dtype_layout(Tensor(a) self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, bool non_blocking=False, bool copy=False, MemoryFormat? memory_format=None) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, c10::optional, c10::optional, bool, bool, c10::optional) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: to + operator_name: to + overload_name: device + manual_kernel_registration: false + category_override: '' + schema_string: aten::to.device(Tensor(a) self, Device device, ScalarType dtype, bool non_blocking=False, bool copy=False, MemoryFormat? memory_format=None) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Device, at::ScalarType, bool, bool, c10::optional) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: to + operator_name: to + overload_name: dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::to.dtype(Tensor(a) self, ScalarType dtype, bool non_blocking=False, bool copy=False, MemoryFormat? memory_format=None) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::ScalarType, bool, bool, c10::optional) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: to + operator_name: to + overload_name: other + manual_kernel_registration: false + category_override: '' + schema_string: aten::to.other(Tensor(a) self, Tensor other, bool non_blocking=False, bool copy=False, MemoryFormat? memory_format=None) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool, c10::optional) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: copy + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + name: memory_format + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: meshgrid + operator_name: meshgrid + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::meshgrid(Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: meshgrid + operator_name: meshgrid + overload_name: indexing + manual_kernel_registration: false + category_override: '' + schema_string: aten::meshgrid.indexing(Tensor[] tensors, *, str indexing) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: indexing + type: c10::string_view + schema_order_cpp_signature: ::std::vector (at::TensorList, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: indexing + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cartesian_prod + operator_name: cartesian_prod + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cartesian_prod(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: combinations + operator_name: combinations + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::combinations(Tensor self, int r=2, bool with_replacement=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: r + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: with_replacement + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: r + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: with_replacement + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: item + operator_name: item + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::item(Tensor self) -> Scalar + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Scalar (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: const at::Scalar & + name: result + type: at::Scalar + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: result_type + operator_name: result_type + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::result_type.Tensor(Tensor tensor, Tensor other) -> ScalarType + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::ScalarType (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::ScalarType + name: result + type: at::ScalarType + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: result_type + operator_name: result_type + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::result_type.Scalar(Tensor tensor, Scalar other) -> ScalarType + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::ScalarType (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::ScalarType + name: result + type: at::ScalarType + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: result_type + operator_name: result_type + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::result_type.Scalar_Tensor(Scalar scalar, Tensor tensor) -> ScalarType + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + schema_order_cpp_signature: at::ScalarType (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::ScalarType + name: result + type: at::ScalarType + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: result_type + operator_name: result_type + overload_name: Scalar_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::result_type.Scalar_Scalar(Scalar scalar1, Scalar scalar2) -> ScalarType + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar1 + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar2 + type: const at::Scalar & + schema_order_cpp_signature: at::ScalarType (const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar1 + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar2 + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::ScalarType + name: result + type: at::ScalarType + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: can_cast + operator_name: can_cast + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::can_cast(ScalarType from, ScalarType to) -> bool + arguments: + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: from + type: at::ScalarType + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: to + type: at::ScalarType + schema_order_cpp_signature: bool (at::ScalarType, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: from + type: at::ScalarType + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: to + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: promote_types + operator_name: promote_types + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::promote_types(ScalarType type1, ScalarType type2) -> ScalarType + arguments: + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: type1 + type: at::ScalarType + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: type2 + type: at::ScalarType + schema_order_cpp_signature: at::ScalarType (at::ScalarType, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: type1 + type: at::ScalarType + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: type2 + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::ScalarType + name: result + type: at::ScalarType + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _local_scalar_dense + operator_name: _local_scalar_dense + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_local_scalar_dense(Tensor self) -> Scalar + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Scalar (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: const at::Scalar & + name: result + type: at::Scalar + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _lstm_mps + operator_name: _lstm_mps + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_lstm_mps(Tensor input, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, at::TensorList, bool, int64_t, double, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + - dynamic_type: at::Tensor + name: result5 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lstm_mps_backward + operator_name: lstm_mps_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lstm_mps_backward(Tensor? grad_y, Tensor? grad_hy, Tensor? grad_cy, Tensor z_state, Tensor cell_state_fwd, Tensor input, Tensor layersOutputs, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor[], Tensor[]) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_y + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z_state + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cell_state_fwd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: layersOutputs + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple,::std::vector> (const c10::optional &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, at::TensorList, at::TensorList, bool, int64_t, double, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_y + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z_state + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cell_state_fwd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: layersOutputs + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::TensorList + name: result1 + type: ::std::vector + - dynamic_type: at::TensorList + name: result2 + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_lstm_cell + operator_name: _thnn_fused_lstm_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_lstm_cell(Tensor input_gates, Tensor hidden_gates, Tensor cx, Tensor? input_bias=None, Tensor? hidden_bias=None) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_lstm_cell_backward_impl + operator_name: _thnn_fused_lstm_cell_backward_impl + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_lstm_cell_backward_impl(Tensor? grad_hy, Tensor? grad_cy, Tensor cx, Tensor cy, Tensor workspace, bool has_bias) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + schema_order_cpp_signature: ::std::tuple (const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_lstm_cell_backward + operator_name: _thnn_fused_lstm_cell_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_lstm_cell_backward(Tensor? grad_hy, Tensor? grad_cy, Tensor cx, Tensor cy, Tensor workspace, bool has_bias) -> (Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + schema_order_cpp_signature: ::std::tuple (const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _thnn_differentiable_lstm_cell_backward + operator_name: _thnn_differentiable_lstm_cell_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_differentiable_lstm_cell_backward(Tensor? grad_hy, Tensor? grad_cy, Tensor input_gates, Tensor hidden_gates, Tensor? input_bias, Tensor? hidden_bias, Tensor cx, Tensor cy) -> (Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _thnn_fused_gru_cell + operator_name: _thnn_fused_gru_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_gru_cell(Tensor input_gates, Tensor hidden_gates, Tensor hx, Tensor? input_bias=None, Tensor? hidden_bias=None) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_gru_cell_backward + operator_name: _thnn_fused_gru_cell_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_gru_cell_backward(Tensor grad_hy, Tensor workspace, bool has_bias) -> (Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_hy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_hy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_differentiable_gru_cell_backward + operator_name: _thnn_differentiable_gru_cell_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_differentiable_gru_cell_backward(Tensor grad_hy, Tensor input_gates, Tensor hidden_gates, Tensor hx, Tensor? input_bias, Tensor? hidden_bias) -> (Tensor, Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_hy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_hy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + - dynamic_type: at::Tensor + name: result4 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lstm + operator_name: lstm + overload_name: input + manual_kernel_registration: false + category_override: '' + schema_string: aten::lstm.input(Tensor input, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, at::TensorList, bool, int64_t, double, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lstm + operator_name: lstm + overload_name: data + manual_kernel_registration: false + category_override: '' + schema_string: aten::lstm.data(Tensor data, Tensor batch_sizes, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::TensorList, at::TensorList, bool, int64_t, double, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gru + operator_name: gru + overload_name: input + manual_kernel_registration: false + category_override: '' + schema_string: aten::gru.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gru + operator_name: gru + overload_name: data + manual_kernel_registration: false + category_override: '' + schema_string: aten::gru.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rnn_tanh + operator_name: rnn_tanh + overload_name: input + manual_kernel_registration: false + category_override: '' + schema_string: aten::rnn_tanh.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rnn_tanh + operator_name: rnn_tanh + overload_name: data + manual_kernel_registration: false + category_override: '' + schema_string: aten::rnn_tanh.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rnn_relu + operator_name: rnn_relu + overload_name: input + manual_kernel_registration: false + category_override: '' + schema_string: aten::rnn_relu.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rnn_relu + operator_name: rnn_relu + overload_name: data + manual_kernel_registration: false + category_override: '' + schema_string: aten::rnn_relu.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lstm_cell + operator_name: lstm_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gru_cell + operator_name: gru_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gru_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rnn_tanh_cell + operator_name: rnn_tanh_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rnn_tanh_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: rnn_relu_cell + operator_name: rnn_relu_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rnn_relu_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_ih + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: b_hh + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantized_lstm_cell + operator_name: quantized_lstm_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantized_gru_cell + operator_name: quantized_gru_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_gru_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantized_rnn_relu_cell + operator_name: quantized_rnn_relu_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_rnn_relu_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantized_rnn_tanh_cell + operator_name: quantized_rnn_tanh_cell + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_rnn_tanh_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: w_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: packed_hh + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_ih + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_offsets_hh + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale_hh + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_ih + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: zero_point_hh + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _pack_padded_sequence + operator_name: _pack_padded_sequence + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pack_padded_sequence(Tensor input, Tensor lengths, bool batch_first) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: lengths + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: lengths + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _pack_padded_sequence_backward + operator_name: _pack_padded_sequence_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pack_padded_sequence_backward(Tensor grad, SymInt[] input_size, Tensor batch_sizes, bool batch_first) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _pad_packed_sequence + operator_name: _pad_packed_sequence + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pad_packed_sequence(Tensor data, Tensor batch_sizes, bool batch_first, Scalar padding_value, int total_length) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: padding_value + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: total_length + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, const at::Scalar &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch_sizes + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: padding_value + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: total_length + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: set_ + operator_name: set_ + overload_name: source_Storage + manual_kernel_registration: false + category_override: '' + schema_string: aten::set_.source_Storage(Tensor(a!) self, Storage source) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Storage) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set_ + operator_name: set_ + overload_name: source_Storage_storage_offset + manual_kernel_registration: false + category_override: '' + schema_string: aten::set_.source_Storage_storage_offset(Tensor(a!) self, Storage source, SymInt storage_offset, SymInt[] size, SymInt[] stride=[]) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Storage, int64_t, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set_ + operator_name: set_ + overload_name: source_Tensor_storage_offset + manual_kernel_registration: false + category_override: '' + schema_string: aten::set_.source_Tensor_storage_offset(Tensor(a!) self, Tensor source, SymInt storage_offset, SymInt[] size, SymInt[] stride=[]) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, int64_t, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: set_ + operator_name: set_ + overload_name: source_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::set_.source_Tensor(Tensor(a!) self, Tensor source) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set_ + operator_name: set_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::set_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lift + operator_name: lift + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lift(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lift_fresh + operator_name: lift_fresh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lift_fresh(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lift_fresh_copy + operator_name: lift_fresh_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lift_fresh_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: is_set_to + operator_name: is_set_to + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::is_set_to(Tensor self, Tensor tensor) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_fill_ + operator_name: masked_fill_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_fill_.Scalar(Tensor(a!) self, Tensor mask, Scalar value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_fill + operator_name: masked_fill + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_fill.Scalar(Tensor self, Tensor mask, Scalar value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_fill_ + operator_name: masked_fill_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_fill_.Tensor(Tensor(a!) self, Tensor mask, Tensor value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_fill + operator_name: masked_fill + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_fill.Tensor(Tensor self, Tensor mask, Tensor value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_scatter_ + operator_name: masked_scatter_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_scatter_(Tensor(a!) self, Tensor mask, Tensor source) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_scatter + operator_name: masked_scatter + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_scatter(Tensor self, Tensor mask, Tensor source) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _masked_softmax + operator_name: _masked_softmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_masked_softmax(Tensor self, Tensor mask, int? dim=None, int? mask_type=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _masked_softmax_backward + operator_name: _masked_softmax_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_masked_softmax_backward(Tensor grad_output, Tensor output, Tensor mask, int? dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: view + operator_name: view + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::view(Tensor(a) self, SymInt[] size) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: view + operator_name: view + overload_name: dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::view.dtype(Tensor(a) self, ScalarType dtype) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::ScalarType) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: put_ + operator_name: put_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::put_(Tensor(a!) self, Tensor index, Tensor source, bool accumulate=False) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: put + operator_name: put + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::put(Tensor self, Tensor index, Tensor source, bool accumulate=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_add_out + operator_name: index_add + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_add.out(Tensor self, int dim, Tensor index, Tensor source, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_add_ + operator_name: index_add_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_add_(Tensor(a!) self, int dim, Tensor index, Tensor source, *, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_add + operator_name: index_add + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_add(Tensor self, int dim, Tensor index, Tensor source, *, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_add + operator_name: index_add + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_add.dimname(Tensor self, Dimname dim, Tensor index, Tensor source, *, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_reduce_out + operator_name: index_reduce + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_reduce.out(Tensor self, int dim, Tensor index, Tensor source, str reduce, *, bool include_self=True, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_reduce_ + operator_name: index_reduce_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_reduce_(Tensor(a!) self, int dim, Tensor index, Tensor source, str reduce, *, bool include_self=True) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_reduce + operator_name: index_reduce + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_reduce(Tensor self, int dim, Tensor index, Tensor source, str reduce, *, bool include_self=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_fill_ + operator_name: index_fill_ + overload_name: int_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill_.int_Scalar(Tensor(a!) self, int dim, Tensor index, Scalar value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_fill + operator_name: index_fill + overload_name: int_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill.int_Scalar(Tensor self, int dim, Tensor index, Scalar value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_fill_ + operator_name: index_fill_ + overload_name: int_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill_.int_Tensor(Tensor(a!) self, int dim, Tensor index, Tensor value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_fill + operator_name: index_fill + overload_name: int_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill.int_Tensor(Tensor self, int dim, Tensor index, Tensor value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_fill_ + operator_name: index_fill_ + overload_name: Dimname_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill_.Dimname_Scalar(Tensor(a!) self, Dimname dim, Tensor index, Scalar value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Dimname, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_fill_ + operator_name: index_fill_ + overload_name: Dimname_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill_.Dimname_Tensor(Tensor(a!) self, Dimname dim, Tensor index, Tensor value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Dimname, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_fill + operator_name: index_fill + overload_name: Dimname_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill.Dimname_Scalar(Tensor self, Dimname dim, Tensor index, Scalar value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_fill + operator_name: index_fill + overload_name: Dimname_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill.Dimname_Tensor(Tensor self, Dimname dim, Tensor index, Tensor value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: scatter + operator_name: scatter + overload_name: src + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.src(Tensor self, int dim, Tensor index, Tensor src) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_ + operator_name: scatter_ + overload_name: src + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_.src(Tensor(a!) self, int dim, Tensor index, Tensor src) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_out + operator_name: scatter + overload_name: src_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.src_out(Tensor self, int dim, Tensor index, Tensor src, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter + operator_name: scatter + overload_name: value + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.value(Tensor self, int dim, Tensor index, Scalar value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_ + operator_name: scatter_ + overload_name: value + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_.value(Tensor(a!) self, int dim, Tensor index, Scalar value) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_out + operator_name: scatter + overload_name: value_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.value_out(Tensor self, int dim, Tensor index, Scalar value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter + operator_name: scatter + overload_name: reduce + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.reduce(Tensor self, int dim, Tensor index, Tensor src, *, str reduce) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_ + operator_name: scatter_ + overload_name: reduce + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_.reduce(Tensor(a!) self, int dim, Tensor index, Tensor src, *, str reduce) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_out + operator_name: scatter + overload_name: reduce_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.reduce_out(Tensor self, int dim, Tensor index, Tensor src, *, str reduce, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter + operator_name: scatter + overload_name: value_reduce + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.value_reduce(Tensor self, int dim, Tensor index, Scalar value, *, str reduce) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_ + operator_name: scatter_ + overload_name: value_reduce + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_.value_reduce(Tensor(a!) self, int dim, Tensor index, Scalar value, *, str reduce) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &, c10::string_view) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_out + operator_name: scatter + overload_name: value_reduce_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.value_reduce_out(Tensor self, int dim, Tensor index, Scalar value, *, str reduce, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: reduce + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter + operator_name: scatter + overload_name: dimname_src + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.dimname_src(Tensor self, Dimname dim, Tensor index, Tensor src) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: scatter + operator_name: scatter + overload_name: dimname_value + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter.dimname_value(Tensor self, Dimname dim, Tensor index, Scalar value) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: scatter_add + operator_name: scatter_add + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_add(Tensor self, int dim, Tensor index, Tensor src) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_add_ + operator_name: scatter_add_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_add_(Tensor(a!) self, int dim, Tensor index, Tensor src) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_add_out + operator_name: scatter_add + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_add.out(Tensor self, int dim, Tensor index, Tensor src, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_add + operator_name: scatter_add + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_add.dimname(Tensor self, Dimname dim, Tensor index, Tensor src) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: scatter_reduce + operator_name: scatter_reduce + overload_name: two + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_reduce.two(Tensor self, int dim, Tensor index, Tensor src, str reduce, *, bool include_self=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_reduce_ + operator_name: scatter_reduce_ + overload_name: two + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_reduce_.two(Tensor(a!) self, int dim, Tensor index, Tensor src, str reduce, *, bool include_self=True) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scatter_reduce_out + operator_name: scatter_reduce + overload_name: two_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::scatter_reduce.two_out(Tensor self, int dim, Tensor index, Tensor src, str reduce, *, bool include_self=True, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, c10::string_view, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: include_self + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eq_ + operator_name: eq_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::eq_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eq_ + operator_name: eq_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::eq_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_and_out + operator_name: bitwise_and + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_and_out + operator_name: bitwise_and + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_and + operator_name: bitwise_and + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_and + operator_name: bitwise_and + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and.Scalar_Tensor(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_and + operator_name: bitwise_and + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_and_ + operator_name: bitwise_and_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bitwise_and_ + operator_name: bitwise_and_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __and__ + operator_name: __and__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__and__.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __and__ + operator_name: __and__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__and__.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __iand__ + operator_name: __iand__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__iand__.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __iand__ + operator_name: __iand__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__iand__.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bitwise_or_out + operator_name: bitwise_or + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_or_out + operator_name: bitwise_or + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_or + operator_name: bitwise_or + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bitwise_or + operator_name: bitwise_or + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or.Scalar_Tensor(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_or + operator_name: bitwise_or + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_or_ + operator_name: bitwise_or_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bitwise_or_ + operator_name: bitwise_or_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __or__ + operator_name: __or__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__or__.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __or__ + operator_name: __or__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__or__.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __ior__ + operator_name: __ior__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__ior__.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __ior__ + operator_name: __ior__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__ior__.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bitwise_xor_out + operator_name: bitwise_xor + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_xor_out + operator_name: bitwise_xor + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_xor + operator_name: bitwise_xor + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bitwise_xor + operator_name: bitwise_xor + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor.Scalar_Tensor(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_xor + operator_name: bitwise_xor + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_xor_ + operator_name: bitwise_xor_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: bitwise_xor_ + operator_name: bitwise_xor_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __xor__ + operator_name: __xor__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__xor__.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __xor__ + operator_name: __xor__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__xor__.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __ixor__ + operator_name: __ixor__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__ixor__.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __ixor__ + operator_name: __ixor__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__ixor__.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: __lshift__ + operator_name: __lshift__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__lshift__.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __lshift__ + operator_name: __lshift__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__lshift__.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __ilshift__ + operator_name: __ilshift__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__ilshift__.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __ilshift__ + operator_name: __ilshift__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__ilshift__.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift + operator_name: bitwise_left_shift + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift_ + operator_name: bitwise_left_shift_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift_out + operator_name: bitwise_left_shift + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift + operator_name: bitwise_left_shift + overload_name: Tensor_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift.Tensor_Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift_ + operator_name: bitwise_left_shift_ + overload_name: Tensor_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift_.Tensor_Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift_out + operator_name: bitwise_left_shift + overload_name: Tensor_Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift + operator_name: bitwise_left_shift + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift.Scalar_Tensor(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __rshift__ + operator_name: __rshift__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__rshift__.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __rshift__ + operator_name: __rshift__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__rshift__.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __irshift__ + operator_name: __irshift__ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::__irshift__.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: __irshift__ + operator_name: __irshift__ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::__irshift__.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift + operator_name: bitwise_right_shift + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift_ + operator_name: bitwise_right_shift_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift_out + operator_name: bitwise_right_shift + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift + operator_name: bitwise_right_shift + overload_name: Tensor_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift.Tensor_Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift_ + operator_name: bitwise_right_shift_ + overload_name: Tensor_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift_.Tensor_Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift_out + operator_name: bitwise_right_shift + overload_name: Tensor_Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift + operator_name: bitwise_right_shift + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift.Scalar_Tensor(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tril_ + operator_name: tril_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tril_(Tensor(a!) self, int diagonal=0) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: triu_ + operator_name: triu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::triu_(Tensor(a!) self, int diagonal=0) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: digamma_ + operator_name: digamma_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::digamma_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lerp_ + operator_name: lerp_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::lerp_.Scalar(Tensor(a!) self, Tensor end, Scalar weight) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lerp_ + operator_name: lerp_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::lerp_.Tensor(Tensor(a!) self, Tensor end, Tensor weight) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addbmm_ + operator_name: addbmm_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addbmm_(Tensor(a!) self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addbmm_out + operator_name: addbmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::addbmm.out(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addbmm + operator_name: addbmm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addbmm(Tensor self, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: batch2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: random_ + operator_name: random_ + overload_name: from + manual_kernel_registration: false + category_override: '' + schema_string: aten::random_.from(Tensor(a!) self, int from, int? to, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: from + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: to + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, c10::optional, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: from + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: to + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: random_ + operator_name: random_ + overload_name: to + manual_kernel_registration: false + category_override: '' + schema_string: aten::random_.to(Tensor(a!) self, int to, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: to + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: to + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: random_ + operator_name: random_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::random_(Tensor(a!) self, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: uniform_ + operator_name: uniform_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::uniform_(Tensor(a!) self, float from=0, float to=1, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: from + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: to + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: from + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: to + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cauchy_ + operator_name: cauchy_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cauchy_(Tensor(a!) self, float median=0, float sigma=1, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: median + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: sigma + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: median + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: sigma + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_normal_ + operator_name: log_normal_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_normal_(Tensor(a!) self, float mean=1, float std=2, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: exponential_ + operator_name: exponential_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::exponential_(Tensor(a!) self, float lambd=1, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: lambd + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: lambd + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: geometric_ + operator_name: geometric_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::geometric_(Tensor(a!) self, float p, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: diag_out + operator_name: diag + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::diag.out(Tensor self, int diagonal=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: diag + operator_name: diag + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diag(Tensor self, int diagonal=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cross_out + operator_name: cross + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cross.out(Tensor self, Tensor other, int? dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: cross + operator_name: cross + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cross(Tensor self, Tensor other, int? dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: triu_out + operator_name: triu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::triu.out(Tensor self, int diagonal=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: triu + operator_name: triu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::triu(Tensor self, int diagonal=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tril_out + operator_name: tril + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::tril.out(Tensor self, int diagonal=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tril + operator_name: tril + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tril(Tensor self, int diagonal=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: diagonal + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tril_indices + operator_name: tril_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tril_indices(int row, int col, int offset=0, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, int64_t, int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: triu_indices + operator_name: triu_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::triu_indices(int row, int col, int offset=0, *, ScalarType? dtype=long, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: at::kLong + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, int64_t, int64_t, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: at::kLong + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: trace + operator_name: trace + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::trace(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: trace_backward + operator_name: trace_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::trace_backward(Tensor grad, SymInt[] sizes) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sizes + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: ne_out + operator_name: ne + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ne.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ne + operator_name: ne + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::ne.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ne_out + operator_name: ne + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ne.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ne + operator_name: ne + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::ne.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ne_ + operator_name: ne_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::ne_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ne_ + operator_name: ne_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::ne_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: not_equal_out + operator_name: not_equal + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::not_equal.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: not_equal + operator_name: not_equal + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::not_equal.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: not_equal_out + operator_name: not_equal + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::not_equal.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: not_equal + operator_name: not_equal + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::not_equal.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: not_equal_ + operator_name: not_equal_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::not_equal_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: not_equal_ + operator_name: not_equal_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::not_equal_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: eq_out + operator_name: eq + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::eq.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eq + operator_name: eq + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::eq.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eq_out + operator_name: eq + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::eq.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: eq + operator_name: eq + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::eq.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ge_out + operator_name: ge + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ge.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ge + operator_name: ge + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::ge.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ge_out + operator_name: ge + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ge.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ge + operator_name: ge + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::ge.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ge_ + operator_name: ge_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::ge_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ge_ + operator_name: ge_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::ge_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: greater_equal_out + operator_name: greater_equal + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_equal.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_equal + operator_name: greater_equal + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_equal.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_equal_out + operator_name: greater_equal + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_equal.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_equal + operator_name: greater_equal + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_equal.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_equal_ + operator_name: greater_equal_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_equal_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_equal_ + operator_name: greater_equal_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_equal_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: le_out + operator_name: le + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::le.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: le + operator_name: le + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::le.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: le_out + operator_name: le + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::le.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: le + operator_name: le + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::le.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: le_ + operator_name: le_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::le_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: le_ + operator_name: le_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::le_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: less_equal_out + operator_name: less_equal + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_equal.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_equal + operator_name: less_equal + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_equal.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_equal_out + operator_name: less_equal + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_equal.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_equal + operator_name: less_equal + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_equal.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_equal_ + operator_name: less_equal_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_equal_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_equal_ + operator_name: less_equal_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_equal_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gt_out + operator_name: gt + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::gt.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gt + operator_name: gt + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::gt.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gt_out + operator_name: gt + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::gt.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gt + operator_name: gt + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::gt.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gt_ + operator_name: gt_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::gt_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gt_ + operator_name: gt_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::gt_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: greater_out + operator_name: greater + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater + operator_name: greater + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_out + operator_name: greater + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater + operator_name: greater + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_ + operator_name: greater_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: greater_ + operator_name: greater_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::greater_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lt_out + operator_name: lt + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lt.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lt + operator_name: lt + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::lt.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lt_out + operator_name: lt + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lt.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lt + operator_name: lt + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::lt.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lt_ + operator_name: lt_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::lt_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lt_ + operator_name: lt_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::lt_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: less_out + operator_name: less + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::less.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less + operator_name: less + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::less.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_out + operator_name: less + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::less.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less + operator_name: less + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::less.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_ + operator_name: less_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: less_ + operator_name: less_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::less_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: take_out + operator_name: take + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::take.out(Tensor self, Tensor index, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: take + operator_name: take + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::take(Tensor self, Tensor index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: take_along_dim_out + operator_name: take_along_dim + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::take_along_dim.out(Tensor self, Tensor indices, int? dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: take_along_dim + operator_name: take_along_dim + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::take_along_dim(Tensor self, Tensor indices, int? dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_select_out + operator_name: index_select + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_select.out(Tensor self, int dim, Tensor index, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_select + operator_name: index_select + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_select(Tensor self, int dim, Tensor index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_select_out + operator_name: index_select + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_select.dimname_out(Tensor self, Dimname dim, Tensor index, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_select + operator_name: index_select + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_select.dimname(Tensor self, Dimname dim, Tensor index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: index_select_backward + operator_name: index_select_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_select_backward(Tensor grad, SymInt[] self_sizes, int dim, Tensor index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: self_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: self_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: masked_select_out + operator_name: masked_select + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_select.out(Tensor self, Tensor mask, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_select + operator_name: masked_select + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_select(Tensor self, Tensor mask) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_select_backward + operator_name: masked_select_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_select_backward(Tensor grad, Tensor input, Tensor mask) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: nonzero_out + operator_name: nonzero + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nonzero.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nonzero + operator_name: nonzero + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nonzero(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nonzero_static_out + operator_name: nonzero_static + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nonzero_static.out(Tensor self, *, int size, int fill_value=-1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: size + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: fill_value + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: size + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: fill_value + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nonzero_static + operator_name: nonzero_static + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nonzero_static(Tensor self, *, int size, int fill_value=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: size + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: fill_value + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: size + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: fill_value + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nonzero_numpy + operator_name: nonzero_numpy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nonzero_numpy(Tensor self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::vector (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: argwhere + operator_name: argwhere + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::argwhere(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gather_out + operator_name: gather + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::gather.out(Tensor self, int dim, Tensor index, *, bool sparse_grad=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gather + operator_name: gather + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gather(Tensor self, int dim, Tensor index, *, bool sparse_grad=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: gather_backward + operator_name: gather_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::gather_backward(Tensor grad, Tensor self, int dim, Tensor index, bool sparse_grad) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse_grad + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: sparse_grad + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: gather_out + operator_name: gather + overload_name: dimname_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::gather.dimname_out(Tensor self, Dimname dim, Tensor index, *, bool sparse_grad=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Dimname, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: gather + operator_name: gather + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::gather.dimname(Tensor self, Dimname dim, Tensor index, *, bool sparse_grad=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: sparse_grad + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _gather_sparse_backward + operator_name: _gather_sparse_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_gather_sparse_backward(Tensor self, int dim, Tensor index, Tensor grad) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: addcmul_out + operator_name: addcmul + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::addcmul.out(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addcmul + operator_name: addcmul + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addcmul(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addcmul_ + operator_name: addcmul_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addcmul_(Tensor(a!) self, Tensor tensor1, Tensor tensor2, *, Scalar value=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addcdiv_out + operator_name: addcdiv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::addcdiv.out(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addcdiv + operator_name: addcdiv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addcdiv(Tensor self, Tensor tensor1, Tensor tensor2, *, Scalar value=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: addcdiv_ + operator_name: addcdiv_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::addcdiv_(Tensor(a!) self, Tensor tensor1, Tensor tensor2, *, Scalar value=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tensor2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: value + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cross_entropy_loss + operator_name: cross_entropy_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cross_entropy_loss(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, SymInt ignore_index=-100, float label_smoothing=0.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: label_smoothing + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: label_smoothing + type: double + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: triangular_solve_out + operator_name: triangular_solve + overload_name: X + manual_kernel_registration: false + category_override: '' + schema_string: aten::triangular_solve.X(Tensor self, Tensor A, bool upper=True, bool transpose=False, bool unitriangular=False, *, Tensor(a!) X, Tensor(b!) M) -> (Tensor(a!) solution, Tensor(b!) cloned_coefficient) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: solution + is_nullable: false + name: X + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: cloned_coefficient + is_nullable: false + name: M + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unitriangular + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unitriangular + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: solution + is_nullable: false + name: X + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: cloned_coefficient + is_nullable: false + name: M + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: solution + name: X + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: cloned_coefficient + name: M + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: triangular_solve + operator_name: triangular_solve + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::triangular_solve(Tensor self, Tensor A, bool upper=True, bool transpose=False, bool unitriangular=False) -> (Tensor solution, Tensor cloned_coefficient) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unitriangular + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unitriangular + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: solution + name: solution + type: at::Tensor + - dynamic_type: at::Tensor + field_name: cloned_coefficient + name: cloned_coefficient + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_check_errors + operator_name: _linalg_check_errors + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_check_errors(Tensor info, str api_name, *, bool is_matrix) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: info + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: api_name + type: c10::string_view + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: is_matrix + type: bool + schema_order_cpp_signature: void (const at::Tensor &, c10::string_view, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: info + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: api_name + type: c10::string_view + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: is_matrix + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_solve_triangular_out + operator_name: linalg_solve_triangular + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_solve_triangular.out(Tensor self, Tensor B, *, bool upper, bool left=True, bool unitriangular=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unitriangular + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unitriangular + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_solve_triangular + operator_name: linalg_solve_triangular + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_solve_triangular(Tensor self, Tensor B, *, bool upper, bool left=True, bool unitriangular=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unitriangular + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unitriangular + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_vander + operator_name: linalg_vander + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_vander(Tensor x, *, SymInt? N=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: N + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: N + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: svd_out + operator_name: svd + overload_name: U + manual_kernel_registration: false + category_override: '' + schema_string: aten::svd.U(Tensor self, bool some=True, bool compute_uv=True, *, Tensor(a!) U, Tensor(b!) S, Tensor(c!) V) -> (Tensor(a!) U, Tensor(b!) S, Tensor(c!) V) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: S + is_nullable: false + name: S + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: V + is_nullable: false + name: V + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: S + is_nullable: false + name: S + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: V + is_nullable: false + name: V + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: S + name: S + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: V + name: V + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: svd + operator_name: svd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::svd(Tensor self, bool some=True, bool compute_uv=True) -> (Tensor U, Tensor S, Tensor V) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor + - dynamic_type: at::Tensor + field_name: S + name: S + type: at::Tensor + - dynamic_type: at::Tensor + field_name: V + name: V + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: swapaxes + operator_name: swapaxes + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::swapaxes(Tensor(a) self, int axis0, int axis1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis1 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis1 + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: swapaxes_ + operator_name: swapaxes_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::swapaxes_(Tensor(a!) self, int axis0, int axis1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis1 + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis1 + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: swapdims + operator_name: swapdims + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::swapdims(Tensor(a) self, int dim0, int dim1) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: swapdims_ + operator_name: swapdims_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::swapdims_(Tensor(a!) self, int dim0, int dim1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: cholesky_out + operator_name: cholesky + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cholesky.out(Tensor self, bool upper=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cholesky + operator_name: cholesky + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cholesky(Tensor self, bool upper=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cholesky_solve_out + operator_name: cholesky_solve + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cholesky_solve.out(Tensor self, Tensor input2, bool upper=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cholesky_solve + operator_name: cholesky_solve + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cholesky_solve(Tensor self, Tensor input2, bool upper=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cholesky_solve_helper + operator_name: _cholesky_solve_helper + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cholesky_solve_helper(Tensor self, Tensor A, bool upper) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: upper + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cholesky_inverse + operator_name: cholesky_inverse + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cholesky_inverse(Tensor self, bool upper=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: cholesky_inverse_out + operator_name: cholesky_inverse + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cholesky_inverse.out(Tensor self, bool upper=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: qr_out + operator_name: qr + overload_name: Q + manual_kernel_registration: false + category_override: '' + schema_string: aten::qr.Q(Tensor self, bool some=True, *, Tensor(a!) Q, Tensor(b!) R) -> (Tensor(a!) Q, Tensor(b!) R) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: Q + is_nullable: false + name: Q + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: R + is_nullable: false + name: R + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: Q + is_nullable: false + name: Q + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: R + is_nullable: false + name: R + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: Q + name: Q + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: R + name: R + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: qr + operator_name: qr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::qr(Tensor self, bool some=True) -> (Tensor Q, Tensor R) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: some + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: Q + name: Q + type: at::Tensor + - dynamic_type: at::Tensor + field_name: R + name: R + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: geqrf_out + operator_name: geqrf + overload_name: a + manual_kernel_registration: false + category_override: '' + schema_string: aten::geqrf.a(Tensor self, *, Tensor(a!) a, Tensor(b!) tau) -> (Tensor(a!) a, Tensor(b!) tau) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: a + is_nullable: false + name: a + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: tau + is_nullable: false + name: tau + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: a + is_nullable: false + name: a + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: tau + is_nullable: false + name: tau + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: a + name: a + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: tau + name: tau + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: geqrf + operator_name: geqrf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::geqrf(Tensor self) -> (Tensor a, Tensor tau) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: a + name: a + type: at::Tensor + - dynamic_type: at::Tensor + field_name: tau + name: tau + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: orgqr + operator_name: orgqr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::orgqr(Tensor self, Tensor input2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: orgqr_out + operator_name: orgqr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::orgqr.out(Tensor self, Tensor input2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ormqr_out + operator_name: ormqr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ormqr.out(Tensor self, Tensor input2, Tensor input3, bool left=True, bool transpose=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input3 + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input3 + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ormqr + operator_name: ormqr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ormqr(Tensor self, Tensor input2, Tensor input3, bool left=True, bool transpose=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input3 + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input3 + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: transpose + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _lu_with_info + operator_name: _lu_with_info + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_lu_with_info(Tensor self, bool pivot=True, bool check_errors=True) -> (Tensor LU, Tensor pivots, Tensor info) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: pivot + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: pivot + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: check_errors + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lu_solve_out + operator_name: lu_solve + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lu_solve.out(Tensor self, Tensor LU_data, Tensor LU_pivots, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lu_solve + operator_name: lu_solve + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lu_solve(Tensor self, Tensor LU_data, Tensor LU_pivots) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lu_unpack + operator_name: lu_unpack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lu_unpack(Tensor LU_data, Tensor LU_pivots, bool unpack_data=True, bool unpack_pivots=True) -> (Tensor P, Tensor L, Tensor U) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_data + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_pivots + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_data + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_pivots + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: P + name: P + type: at::Tensor + - dynamic_type: at::Tensor + field_name: L + name: L + type: at::Tensor + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lu_unpack_out + operator_name: lu_unpack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lu_unpack.out(Tensor LU_data, Tensor LU_pivots, bool unpack_data=True, bool unpack_pivots=True, *, Tensor(a!) P, Tensor(b!) L, Tensor(c!) U) -> (Tensor(a!) P, Tensor(b!) L, Tensor(c!) U) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: P + is_nullable: false + name: P + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: L + is_nullable: false + name: L + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_data + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_pivots + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_data + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU_pivots + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_data + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: unpack_pivots + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: P + is_nullable: false + name: P + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: L + is_nullable: false + name: L + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: P + name: P + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: L + name: L + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multinomial_out + operator_name: multinomial + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::multinomial.out(Tensor self, int num_samples, bool replacement=False, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_samples + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: replacement + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_samples + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: replacement + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multinomial + operator_name: multinomial + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::multinomial(Tensor self, int num_samples, bool replacement=False, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_samples + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: replacement + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_samples + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: replacement + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lgamma_out + operator_name: lgamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lgamma.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lgamma_ + operator_name: lgamma_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lgamma_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lgamma + operator_name: lgamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::lgamma(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: digamma_out + operator_name: digamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::digamma.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: digamma + operator_name: digamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::digamma(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: polygamma_out + operator_name: polygamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::polygamma.out(int n, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: polygamma + operator_name: polygamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::polygamma(int n, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: polygamma_ + operator_name: polygamma_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::polygamma_(Tensor(a!) self, int n) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erfinv + operator_name: erfinv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::erfinv(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erfinv_ + operator_name: erfinv_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::erfinv_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: erfinv_out + operator_name: erfinv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::erfinv.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: i0 + operator_name: i0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::i0(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: i0_ + operator_name: i0_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::i0_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: i0_out + operator_name: i0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::i0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sign + operator_name: sign + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sign(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sign_ + operator_name: sign_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sign_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sign_out + operator_name: sign + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sign.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: signbit + operator_name: signbit + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::signbit(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: signbit_out + operator_name: signbit + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::signbit.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: dist + operator_name: dist + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::dist(Tensor self, Tensor other, Scalar p=2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: atan2_out + operator_name: atan2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::atan2.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: atan2_ + operator_name: atan2_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atan2_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: atan2 + operator_name: atan2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::atan2(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: arctan2 + operator_name: arctan2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctan2(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arctan2_out + operator_name: arctan2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctan2.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: arctan2_ + operator_name: arctan2_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::arctan2_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: lerp_out + operator_name: lerp + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lerp.Scalar_out(Tensor self, Tensor end, Scalar weight, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lerp_out + operator_name: lerp + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lerp.Tensor_out(Tensor self, Tensor end, Tensor weight, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lerp + operator_name: lerp + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::lerp.Scalar(Tensor self, Tensor end, Scalar weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: lerp + operator_name: lerp + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::lerp.Tensor(Tensor self, Tensor end, Tensor weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: end + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: histc_out + operator_name: histc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::histc.out(Tensor self, int bins=100, Scalar min=0, Scalar max=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: histc + operator_name: histc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::histc(Tensor self, int bins=100, Scalar min=0, Scalar max=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: min + type: const at::Scalar & + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: max + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: histogram_out + operator_name: histogram + overload_name: bins_tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::histogram.bins_tensor_out(Tensor self, Tensor bins, *, Tensor? weight=None, bool density=False, Tensor(a!) hist, Tensor(b!) bin_edges) -> (Tensor(a!) hist, Tensor(b!) bin_edges) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: hist + is_nullable: false + name: hist + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: bin_edges + is_nullable: false + name: bin_edges + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bins + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bins + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: hist + is_nullable: false + name: hist + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: bin_edges + is_nullable: false + name: bin_edges + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: hist + name: hist + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: bin_edges + name: bin_edges + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: histogram + operator_name: histogram + overload_name: bins_tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::histogram.bins_tensor(Tensor self, Tensor bins, *, Tensor? weight=None, bool density=False) -> (Tensor hist, Tensor bin_edges) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bins + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bins + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: hist + name: hist + type: at::Tensor + - dynamic_type: at::Tensor + field_name: bin_edges + name: bin_edges + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: histogram_out + operator_name: histogram + overload_name: bin_ct_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::histogram.bin_ct_out(Tensor self, int bins=100, *, float[]? range=None, Tensor? weight=None, bool density=False, Tensor(a!) hist, Tensor(b!) bin_edges) -> (Tensor(a!) hist, Tensor(b!) bin_edges) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: hist + is_nullable: false + name: hist + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: bin_edges + is_nullable: false + name: bin_edges + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, c10::optional>, const c10::optional &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: hist + is_nullable: false + name: hist + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: bin_edges + is_nullable: false + name: bin_edges + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: hist + name: hist + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: bin_edges + name: bin_edges + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: histogram + operator_name: histogram + overload_name: bin_ct + manual_kernel_registration: false + category_override: '' + schema_string: aten::histogram.bin_ct(Tensor self, int bins=100, *, float[]? range=None, Tensor? weight=None, bool density=False) -> (Tensor hist, Tensor bin_edges) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, c10::optional>, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 100 + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: hist + name: hist + type: at::Tensor + - dynamic_type: at::Tensor + field_name: bin_edges + name: bin_edges + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _histogramdd_bin_edges + operator_name: _histogramdd_bin_edges + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_histogramdd_bin_edges(Tensor self, int[] bins, *, float[]? range=None, Tensor? weight=None, bool density=False) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef, c10::optional>, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _histogramdd_from_bin_cts + operator_name: _histogramdd_from_bin_cts + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_histogramdd_from_bin_cts(Tensor self, int[] bins, *, float[]? range=None, Tensor? weight=None, bool density=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional>, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _histogramdd_from_bin_tensors + operator_name: _histogramdd_from_bin_tensors + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_histogramdd_from_bin_tensors(Tensor self, Tensor[] bins, *, Tensor? weight=None, bool density=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: bins + type: at::TensorList + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::TensorList, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: bins + type: at::TensorList + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: histogramdd + operator_name: histogramdd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::histogramdd(Tensor self, int[] bins, float[]? range=None, Tensor? weight=None, bool density=False) -> (Tensor hist, Tensor[] bin_edges) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: density + type: bool + schema_order_cpp_signature: ::std::tuple> (const at::Tensor &, at::IntArrayRef, c10::optional>, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: density + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: hist + name: hist + type: at::Tensor + - dynamic_type: at::TensorList + field_name: bin_edges + name: bin_edges + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: histogramdd + operator_name: histogramdd + overload_name: int_bins + manual_kernel_registration: false + category_override: '' + schema_string: aten::histogramdd.int_bins(Tensor self, int bins, float[]? range=None, Tensor? weight=None, bool density=False) -> (Tensor hist, Tensor[] bin_edges) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: density + type: bool + schema_order_cpp_signature: ::std::tuple> (const at::Tensor &, int64_t, c10::optional>, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: bins + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: density + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: hist + name: hist + type: at::Tensor + - dynamic_type: at::TensorList + field_name: bin_edges + name: bin_edges + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: histogramdd + operator_name: histogramdd + overload_name: TensorList_bins + manual_kernel_registration: false + category_override: '' + schema_string: aten::histogramdd.TensorList_bins(Tensor self, Tensor[] bins, float[]? range=None, Tensor? weight=None, bool density=False) -> (Tensor hist, Tensor[] bin_edges) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: bins + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: density + type: bool + schema_order_cpp_signature: ::std::tuple> (const at::Tensor &, at::TensorList, c10::optional>, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: bins + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: density + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: hist + name: hist + type: at::Tensor + - dynamic_type: at::TensorList + field_name: bin_edges + name: bin_edges + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fmod_out + operator_name: fmod + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmod.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmod + operator_name: fmod + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmod.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmod_ + operator_name: fmod_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmod_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmod_out + operator_name: fmod + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmod.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmod + operator_name: fmod + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmod.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmod_ + operator_name: fmod_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmod_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hypot_out + operator_name: hypot + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hypot.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hypot + operator_name: hypot + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hypot(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hypot_ + operator_name: hypot_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hypot_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: igamma_out + operator_name: igamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::igamma.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: igamma + operator_name: igamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::igamma(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: igamma_ + operator_name: igamma_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::igamma_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: igammac_out + operator_name: igammac + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::igammac.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: igammac + operator_name: igammac + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::igammac(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: igammac_ + operator_name: igammac_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::igammac_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nextafter_out + operator_name: nextafter + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nextafter.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nextafter + operator_name: nextafter + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nextafter(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nextafter_ + operator_name: nextafter_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nextafter_(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder_out + operator_name: remainder + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder + operator_name: remainder + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder.Scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder_ + operator_name: remainder_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder_out + operator_name: remainder + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder + operator_name: remainder + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder.Tensor(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder_ + operator_name: remainder_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder + operator_name: remainder + overload_name: Scalar_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder.Scalar_Tensor(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: min + operator_name: min + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::min(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: min_out + operator_name: min + overload_name: unary_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::min.unary_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmin + operator_name: fmin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmin(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmin_out + operator_name: fmin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmin.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max + operator_name: max + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmax + operator_name: fmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmax(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fmax_out + operator_name: fmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fmax.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: maximum + operator_name: maximum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::maximum(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: maximum_out + operator_name: maximum + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::maximum.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max + operator_name: max + overload_name: other + manual_kernel_registration: false + category_override: '' + schema_string: aten::max.other(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: max_out + operator_name: max + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::max.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: max_out + operator_name: max + overload_name: unary_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::max.unary_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: minimum + operator_name: minimum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::minimum(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: minimum_out + operator_name: minimum + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::minimum.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: min_out + operator_name: min + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::min.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: min + operator_name: min + overload_name: other + manual_kernel_registration: false + category_override: '' + schema_string: aten::min.other(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantile + operator_name: quantile + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantile(Tensor self, Tensor q, int? dim=None, bool keepdim=False, *, str interpolation='linear') -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional, bool, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantile_out + operator_name: quantile + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantile.out(Tensor self, Tensor q, int? dim=None, bool keepdim=False, *, str interpolation='linear', Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, bool, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantile + operator_name: quantile + overload_name: scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantile.scalar(Tensor self, float q, int? dim=None, bool keepdim=False, *, str interpolation='linear') -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, c10::optional, bool, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: quantile_out + operator_name: quantile + overload_name: scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantile.scalar_out(Tensor self, float q, int? dim=None, bool keepdim=False, *, str interpolation='linear', Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, c10::optional, bool, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanquantile + operator_name: nanquantile + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanquantile(Tensor self, Tensor q, int? dim=None, bool keepdim=False, *, str interpolation='linear') -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional, bool, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanquantile_out + operator_name: nanquantile + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanquantile.out(Tensor self, Tensor q, int? dim=None, bool keepdim=False, *, str interpolation='linear', Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, bool, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanquantile + operator_name: nanquantile + overload_name: scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanquantile.scalar(Tensor self, float q, int? dim=None, bool keepdim=False, *, str interpolation='linear') -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, c10::optional, bool, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nanquantile_out + operator_name: nanquantile + overload_name: scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanquantile.scalar_out(Tensor self, float q, int? dim=None, bool keepdim=False, *, str interpolation='linear', Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, c10::optional, bool, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: q + type: double + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: '"linear"' + dynamic_type: c10::string_view + is_nullable: false + kwarg_only: true + name: interpolation + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sort_out + operator_name: sort + overload_name: values + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort.values(Tensor self, int dim=-1, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sort_out + operator_name: sort + overload_name: values_stable + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort.values_stable(Tensor self, *, bool? stable, int dim=-1, bool descending=False, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::optional, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sort + operator_name: sort + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort(Tensor self, int dim=-1, bool descending=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sort + operator_name: sort + overload_name: stable + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort.stable(Tensor self, *, bool? stable, int dim=-1, bool descending=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::optional, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sort_out + operator_name: sort + overload_name: dimname_values + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort.dimname_values(Tensor self, Dimname dim, bool descending=False, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sort_out + operator_name: sort + overload_name: dimname_values_stable + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort.dimname_values_stable(Tensor self, *, bool? stable, Dimname dim, bool descending=False, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::optional, at::Dimname, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sort + operator_name: sort + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort.dimname(Tensor self, Dimname dim, bool descending=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: sort + operator_name: sort + overload_name: dimname_stable + manual_kernel_registration: false + category_override: '' + schema_string: aten::sort.dimname_stable(Tensor self, *, bool? stable, Dimname dim, bool descending=False) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::optional, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: stable + type: c10::optional + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + kwarg_only: true + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: msort_out + operator_name: msort + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::msort.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: msort + operator_name: msort + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::msort(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: argsort + operator_name: argsort + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::argsort(Tensor self, int dim=-1, bool descending=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: argsort + operator_name: argsort + overload_name: stable + manual_kernel_registration: false + category_override: '' + schema_string: aten::argsort.stable(Tensor self, *, bool stable, int dim=-1, bool descending=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: stable + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: stable + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: argsort + operator_name: argsort + overload_name: dimname + manual_kernel_registration: false + category_override: '' + schema_string: aten::argsort.dimname(Tensor self, Dimname dim, bool descending=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Dimname, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Dimname + is_nullable: false + name: dim + type: at::Dimname + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: descending + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: topk_out + operator_name: topk + overload_name: values + manual_kernel_registration: false + category_override: '' + schema_string: aten::topk.values(Tensor self, SymInt k, int dim=-1, bool largest=True, bool sorted=True, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: largest + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, int64_t, bool, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: largest + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: values + is_nullable: false + name: values + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: indices + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: topk + operator_name: topk + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::topk(Tensor self, SymInt k, int dim=-1, bool largest=True, bool sorted=True) -> (Tensor values, Tensor indices) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: largest + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: largest + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: values + name: values + type: at::Tensor + - dynamic_type: at::Tensor + field_name: indices + name: indices + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: all + operator_name: all + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::all(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: all_out + operator_name: all + overload_name: all_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::all.all_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: any + operator_name: any + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::any(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: any_out + operator_name: any + overload_name: all_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::any.all_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: renorm_out + operator_name: renorm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::renorm.out(Tensor self, Scalar p, int dim, Scalar maxnorm, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: maxnorm + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, int64_t, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: maxnorm + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: renorm + operator_name: renorm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::renorm(Tensor self, Scalar p, int dim, Scalar maxnorm) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: maxnorm + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, int64_t, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: maxnorm + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: renorm_ + operator_name: renorm_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::renorm_(Tensor(a!) self, Scalar p, int dim, Scalar maxnorm) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: maxnorm + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, int64_t, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: maxnorm + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unfold + operator_name: unfold + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unfold(Tensor(a) self, int dimension, int size, int step) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unfold_backward + operator_name: unfold_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unfold_backward(Tensor grad_in, SymInt[] input_sizes, int dim, int size, int step) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_in + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_in + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: equal + operator_name: equal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::equal(Tensor self, Tensor other) -> bool + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: bool (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: bool + name: result + type: bool + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow_out + operator_name: pow + overload_name: Tensor_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow.Tensor_Tensor_out(Tensor self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow + operator_name: pow + overload_name: Tensor_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow.Tensor_Tensor(Tensor self, Tensor exponent) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow_out + operator_name: pow + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow.Scalar_out(Scalar self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow + operator_name: pow + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow.Scalar(Scalar self, Tensor exponent) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow_out + operator_name: pow + overload_name: Tensor_Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow.Tensor_Scalar_out(Tensor self, Scalar exponent, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow + operator_name: pow + overload_name: Tensor_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow.Tensor_Scalar(Tensor self, Scalar exponent) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow_ + operator_name: pow_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow_.Scalar(Tensor(a!) self, Scalar exponent) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pow_ + operator_name: pow_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::pow_.Tensor(Tensor(a!) self, Tensor exponent) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: float_power_out + operator_name: float_power + overload_name: Tensor_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power.Tensor_Tensor_out(Tensor self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: float_power + operator_name: float_power + overload_name: Tensor_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power.Tensor_Tensor(Tensor self, Tensor exponent) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: float_power_out + operator_name: float_power + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power.Scalar_out(Scalar self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: float_power + operator_name: float_power + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power.Scalar(Scalar self, Tensor exponent) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: float_power_out + operator_name: float_power + overload_name: Tensor_Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power.Tensor_Scalar_out(Tensor self, Scalar exponent, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: float_power + operator_name: float_power + overload_name: Tensor_Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power.Tensor_Scalar(Tensor self, Scalar exponent) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: float_power_ + operator_name: float_power_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power_.Scalar(Tensor(a!) self, Scalar exponent) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: float_power_ + operator_name: float_power_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::float_power_.Tensor(Tensor(a!) self, Tensor exponent) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: exponent + type: const at::Tensor & + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: normal_ + operator_name: normal_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal_(Tensor(a!) self, float mean=0, float std=1, *, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal_functional + operator_name: normal_functional + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal_functional(Tensor self, float mean=0, float std=1, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal_out + operator_name: normal + overload_name: Tensor_float_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.Tensor_float_out(Tensor mean, float std=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal + operator_name: normal + overload_name: Tensor_float + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.Tensor_float(Tensor mean, float std=1, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal_out + operator_name: normal + overload_name: float_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.float_Tensor_out(float mean, Tensor std, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (double, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal + operator_name: normal + overload_name: float_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.float_Tensor(float mean, Tensor std, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (double, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal_out + operator_name: normal + overload_name: Tensor_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.Tensor_Tensor_out(Tensor mean, Tensor std, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal + operator_name: normal + overload_name: Tensor_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.Tensor_Tensor(Tensor mean, Tensor std, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: std + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal + operator_name: normal + overload_name: float_float + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.float_float(float mean, float std, SymInt[] size, *, Generator? generator=None, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (double, double, at::IntArrayRef, c10::optional, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal_out + operator_name: normal + overload_name: float_float_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.float_float_out(float mean, float std, SymInt[] size, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (double, double, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: alias + operator_name: alias + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::alias(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _amp_foreach_non_finite_check_and_unscale_ + operator_name: _amp_foreach_non_finite_check_and_unscale_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_amp_foreach_non_finite_check_and_unscale_(Tensor(a!)[] self, Tensor(b!) found_inf, Tensor inv_scale) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: inv_scale + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: inv_scale + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _amp_update_scale_ + operator_name: _amp_update_scale_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_amp_update_scale_(Tensor(a!) self, Tensor(b!) growth_tracker, Tensor found_inf, float scale_growth_factor, float scale_backoff_factor, int growth_interval) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: growth_tracker + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_growth_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_backoff_factor + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: growth_interval + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, at::Tensor &, const at::Tensor &, double, double, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: growth_tracker + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_growth_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_backoff_factor + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: growth_interval + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add + operator_name: _foreach_add + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add_ + operator_name: _foreach_add_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add + operator_name: _foreach_add + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add.List(Tensor[] self, Tensor[] other, *, Scalar alpha=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add_ + operator_name: _foreach_add_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add_.List(Tensor(a!)[] self, Tensor[] other, *, Scalar alpha=1) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add + operator_name: _foreach_add + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add_ + operator_name: _foreach_add_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub + operator_name: _foreach_sub + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub_ + operator_name: _foreach_sub_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub + operator_name: _foreach_sub + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub.List(Tensor[] self, Tensor[] other, *, Scalar alpha=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub_ + operator_name: _foreach_sub_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub_.List(Tensor(a!)[] self, Tensor[] other, *, Scalar alpha=1) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub + operator_name: _foreach_sub + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub_ + operator_name: _foreach_sub_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul + operator_name: _foreach_mul + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_ + operator_name: _foreach_mul_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul + operator_name: _foreach_mul + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.List(Tensor[] self, Tensor[] other) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_ + operator_name: _foreach_mul_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul_.List(Tensor(a!)[] self, Tensor[] other) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul + operator_name: _foreach_mul + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_ + operator_name: _foreach_mul_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul + operator_name: _foreach_mul + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.Tensor(Tensor[] self, Tensor other) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_ + operator_name: _foreach_mul_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul_.Tensor(Tensor(a!)[] self, Tensor other) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div + operator_name: _foreach_div + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div_ + operator_name: _foreach_div_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div + operator_name: _foreach_div + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div.List(Tensor[] self, Tensor[] other) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div_ + operator_name: _foreach_div_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div_.List(Tensor(a!)[] self, Tensor[] other) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div + operator_name: _foreach_div + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div_ + operator_name: _foreach_div_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max + operator_name: _foreach_clamp_max + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max_ + operator_name: _foreach_clamp_max_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max + operator_name: _foreach_clamp_max + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max.List(Tensor[] self, Tensor[] other) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max_ + operator_name: _foreach_clamp_max_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max_.List(Tensor(a!)[] self, Tensor[] other) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max + operator_name: _foreach_clamp_max + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max_ + operator_name: _foreach_clamp_max_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min + operator_name: _foreach_clamp_min + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min_ + operator_name: _foreach_clamp_min_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min + operator_name: _foreach_clamp_min + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min.List(Tensor[] self, Tensor[] other) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min_ + operator_name: _foreach_clamp_min_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min_.List(Tensor(a!)[] self, Tensor[] other) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min + operator_name: _foreach_clamp_min + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min_ + operator_name: _foreach_clamp_min_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum + operator_name: _foreach_maximum + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum_ + operator_name: _foreach_maximum_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum + operator_name: _foreach_maximum + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum.List(Tensor[] self, Tensor[] other) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum_ + operator_name: _foreach_maximum_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum_.List(Tensor(a!)[] self, Tensor[] other) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum + operator_name: _foreach_maximum + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum_ + operator_name: _foreach_maximum_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum + operator_name: _foreach_minimum + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum.Scalar(Tensor[] self, Scalar scalar) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum_ + operator_name: _foreach_minimum_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum_.Scalar(Tensor(a!)[] self, Scalar scalar) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum + operator_name: _foreach_minimum + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum.List(Tensor[] self, Tensor[] other) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum_ + operator_name: _foreach_minimum_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum_.List(Tensor(a!)[] self, Tensor[] other) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum + operator_name: _foreach_minimum + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum_ + operator_name: _foreach_minimum_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv + operator_name: _foreach_addcdiv + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv.Scalar(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar value=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv + operator_name: _foreach_addcdiv + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv.ScalarList(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv + operator_name: _foreach_addcdiv + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv.Tensor(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Tensor scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, at::TensorList, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv_ + operator_name: _foreach_addcdiv_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv_.Scalar(Tensor(a!)[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar value=1) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv_ + operator_name: _foreach_addcdiv_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv_.ScalarList(Tensor(a!)[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv_ + operator_name: _foreach_addcdiv_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv_.Tensor(Tensor(a!)[] self, Tensor[] tensor1, Tensor[] tensor2, Tensor scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul + operator_name: _foreach_addcmul + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul.Scalar(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar value=1) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul + operator_name: _foreach_addcmul + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul.ScalarList(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar[] scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul + operator_name: _foreach_addcmul + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul.Tensor(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Tensor scalars) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, at::TensorList, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul_ + operator_name: _foreach_addcmul_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul_.Scalar(Tensor(a!)[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar value=1) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul_ + operator_name: _foreach_addcmul_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul_.ScalarList(Tensor(a!)[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar[] scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul_ + operator_name: _foreach_addcmul_ + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul_.Tensor(Tensor(a!)[] self, Tensor[] tensor1, Tensor[] tensor2, Tensor scalars) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_abs + operator_name: _foreach_abs + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_abs(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_abs_ + operator_name: _foreach_abs_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_abs_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_acos + operator_name: _foreach_acos + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_acos(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_acos_ + operator_name: _foreach_acos_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_acos_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_asin + operator_name: _foreach_asin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_asin(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_asin_ + operator_name: _foreach_asin_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_asin_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_atan + operator_name: _foreach_atan + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_atan(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_atan_ + operator_name: _foreach_atan_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_atan_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_ceil + operator_name: _foreach_ceil + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_ceil(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_ceil_ + operator_name: _foreach_ceil_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_ceil_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_cos + operator_name: _foreach_cos + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_cos(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_cos_ + operator_name: _foreach_cos_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_cos_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_cosh + operator_name: _foreach_cosh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_cosh(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_cosh_ + operator_name: _foreach_cosh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_cosh_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_erf + operator_name: _foreach_erf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_erf(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_erf_ + operator_name: _foreach_erf_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_erf_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_erfc + operator_name: _foreach_erfc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_erfc(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_erfc_ + operator_name: _foreach_erfc_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_erfc_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_exp + operator_name: _foreach_exp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_exp(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_exp_ + operator_name: _foreach_exp_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_exp_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_expm1 + operator_name: _foreach_expm1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_expm1(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_expm1_ + operator_name: _foreach_expm1_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_expm1_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_floor + operator_name: _foreach_floor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_floor(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_floor_ + operator_name: _foreach_floor_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_floor_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_frac + operator_name: _foreach_frac + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_frac(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_frac_ + operator_name: _foreach_frac_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_frac_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lerp + operator_name: _foreach_lerp + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lerp.List(Tensor[] self, Tensor[] tensors1, Tensor[] weights) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weights + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weights + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lerp_ + operator_name: _foreach_lerp_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lerp_.List(Tensor(a!)[] self, Tensor[] tensors1, Tensor[] weights) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weights + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weights + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lerp + operator_name: _foreach_lerp + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lerp.Scalar(Tensor[] self, Tensor[] tensors1, Scalar weight) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lerp_ + operator_name: _foreach_lerp_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lerp_.Scalar(Tensor(a!)[] self, Tensor[] tensors1, Scalar weight) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lgamma + operator_name: _foreach_lgamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lgamma(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lgamma_ + operator_name: _foreach_lgamma_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lgamma_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log + operator_name: _foreach_log + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log_ + operator_name: _foreach_log_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log10 + operator_name: _foreach_log10 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log10(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log10_ + operator_name: _foreach_log10_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log10_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log1p + operator_name: _foreach_log1p + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log1p(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log1p_ + operator_name: _foreach_log1p_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log1p_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log2 + operator_name: _foreach_log2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log2(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log2_ + operator_name: _foreach_log2_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log2_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_neg + operator_name: _foreach_neg + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_neg(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_neg_ + operator_name: _foreach_neg_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_neg_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_norm + operator_name: _foreach_norm + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_norm.Scalar(Tensor[] self, Scalar ord=2) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow + operator_name: _foreach_pow + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow.List(Tensor[] self, Tensor[] exponent) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow + operator_name: _foreach_pow + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow.Scalar(Tensor[] self, Scalar exponent) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: ::std::vector (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow + operator_name: _foreach_pow + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow.ScalarList(Tensor[] self, Scalar[] exponent) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: exponent + type: at::ArrayRef + schema_order_cpp_signature: ::std::vector (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: exponent + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow + operator_name: _foreach_pow + overload_name: ScalarAndTensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow.ScalarAndTensor(Scalar self, Tensor[] exponent) -> Tensor[] + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + schema_order_cpp_signature: ::std::vector (const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow_ + operator_name: _foreach_pow_ + overload_name: List + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow_.List(Tensor(a!)[] self, Tensor[] exponent) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow_ + operator_name: _foreach_pow_ + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow_.Scalar(Tensor(a!)[] self, Scalar exponent) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow_ + operator_name: _foreach_pow_ + overload_name: ScalarList + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow_.ScalarList(Tensor(a!)[] self, Scalar[] exponent) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: exponent + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: exponent + type: at::ArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_reciprocal + operator_name: _foreach_reciprocal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_reciprocal(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_reciprocal_ + operator_name: _foreach_reciprocal_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_reciprocal_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_round + operator_name: _foreach_round + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_round(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_round_ + operator_name: _foreach_round_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_round_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sigmoid + operator_name: _foreach_sigmoid + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sigmoid(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sigmoid_ + operator_name: _foreach_sigmoid_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sigmoid_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sign + operator_name: _foreach_sign + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sign(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sign_ + operator_name: _foreach_sign_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sign_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sin + operator_name: _foreach_sin + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sin(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sin_ + operator_name: _foreach_sin_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sin_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sinh + operator_name: _foreach_sinh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sinh(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sinh_ + operator_name: _foreach_sinh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sinh_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sqrt + operator_name: _foreach_sqrt + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sqrt(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sqrt_ + operator_name: _foreach_sqrt_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sqrt_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_tan + operator_name: _foreach_tan + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_tan(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_tan_ + operator_name: _foreach_tan_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_tan_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_tanh + operator_name: _foreach_tanh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_tanh(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_tanh_ + operator_name: _foreach_tanh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_tanh_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_trunc + operator_name: _foreach_trunc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_trunc(Tensor[] self) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_trunc_ + operator_name: _foreach_trunc_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_trunc_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_zero_ + operator_name: _foreach_zero_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_zero_(Tensor(a!)[] self) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_copy_ + operator_name: _foreach_copy_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_copy_(Tensor(a!)[] self, Tensor[] src, bool non_blocking=False) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: src + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: void (at::TensorList, at::TensorList, bool) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: src + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bucketize + operator_name: bucketize + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bucketize.Tensor(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bucketize_out + operator_name: bucketize + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bucketize.Tensor_out(Tensor self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: bucketize + operator_name: bucketize + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::bucketize.Scalar(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: searchsorted + operator_name: searchsorted + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::searchsorted.Tensor(Tensor sorted_sequence, Tensor self, *, bool out_int32=False, bool right=False, str? side=None, Tensor? sorter=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool, c10::optional, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: searchsorted_out + operator_name: searchsorted + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::searchsorted.Tensor_out(Tensor sorted_sequence, Tensor self, *, bool out_int32=False, bool right=False, str? side=None, Tensor? sorter=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, c10::optional, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: searchsorted + operator_name: searchsorted + overload_name: Scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::searchsorted.Scalar(Tensor sorted_sequence, Scalar self, *, bool out_int32=False, bool right=False, str? side=None, Tensor? sorter=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, bool, bool, c10::optional, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: searchsorted_out + operator_name: searchsorted + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::searchsorted.Scalar_out(Tensor sorted_sequence, Scalar self, *, bool out_int32=False, bool right=False, str? side=None, Tensor? sorter=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, bool, bool, c10::optional, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sorted_sequence + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: side + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: sorter + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _convert_indices_from_coo_to_csr + operator_name: _convert_indices_from_coo_to_csr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convert_indices_from_coo_to_csr(Tensor self, int size, *, bool out_int32=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _convert_indices_from_coo_to_csr_out + operator_name: _convert_indices_from_coo_to_csr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convert_indices_from_coo_to_csr.out(Tensor self, int size, *, bool out_int32=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _convert_indices_from_csr_to_coo + operator_name: _convert_indices_from_csr_to_coo + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convert_indices_from_csr_to_coo(Tensor crow_indices, Tensor col_indices, *, bool out_int32=False, bool transpose=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: transpose + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: transpose + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _convert_indices_from_csr_to_coo_out + operator_name: _convert_indices_from_csr_to_coo + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convert_indices_from_csr_to_coo.out(Tensor crow_indices, Tensor col_indices, *, bool out_int32=False, bool transpose=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: transpose + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: crow_indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: col_indices + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: transpose + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mse_loss_out + operator_name: mse_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mse_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mse_loss + operator_name: mse_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mse_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mse_loss_backward_out + operator_name: mse_loss_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::mse_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mse_loss_backward + operator_name: mse_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mse_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: l1_loss + operator_name: l1_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::l1_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: multi_margin_loss_out + operator_name: multi_margin_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::multi_margin_loss.out(Tensor self, Tensor target, Scalar p=1, Scalar margin=1, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const c10::optional &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multi_margin_loss + operator_name: multi_margin_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::multi_margin_loss(Tensor self, Tensor target, Scalar p=1, Scalar margin=1, Tensor? weight=None, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multi_margin_loss_backward_out + operator_name: multi_margin_loss_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::multi_margin_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Scalar p, Scalar margin, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const c10::optional &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multi_margin_loss_backward + operator_name: multi_margin_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::multi_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, Scalar p, Scalar margin, Tensor? weight=None, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const c10::optional &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: margin + type: const at::Scalar & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multilabel_margin_loss_out + operator_name: multilabel_margin_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::multilabel_margin_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: multilabel_margin_loss + operator_name: multilabel_margin_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::multilabel_margin_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: multilabel_margin_loss_forward_out + operator_name: multilabel_margin_loss_forward + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::multilabel_margin_loss_forward.output(Tensor self, Tensor target, int reduction, *, Tensor(a!) output, Tensor(b!) is_target) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: is_target + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: is_target + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + - dynamic_type: at::Tensor + name: is_target + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multilabel_margin_loss_forward + operator_name: multilabel_margin_loss_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::multilabel_margin_loss_forward(Tensor self, Tensor target, int reduction) -> (Tensor output, Tensor is_target) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: is_target + name: is_target + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multilabel_margin_loss_backward_out + operator_name: multilabel_margin_loss_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::multilabel_margin_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, Tensor is_target, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: is_target + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: is_target + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: multilabel_margin_loss_backward + operator_name: multilabel_margin_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::multilabel_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction, Tensor is_target) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: is_target + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: is_target + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss_out + operator_name: nll_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, SymInt ignore_index=-100, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nll_loss_nd + operator_name: nll_loss_nd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss_nd(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, SymInt ignore_index=-100) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nll_loss + operator_name: nll_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, SymInt ignore_index=-100) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nll_loss_forward_out + operator_name: nll_loss_forward + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss_forward.output(Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index, *, Tensor(a!) output, Tensor(b!) total_weight) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + - dynamic_type: at::Tensor + name: total_weight + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss_forward + operator_name: nll_loss_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss_forward(Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index) -> (Tensor output, Tensor total_weight) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: total_weight + name: total_weight + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss_backward_out + operator_name: nll_loss_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index, Tensor total_weight, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss_backward + operator_name: nll_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index, Tensor total_weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss2d_out + operator_name: nll_loss2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss2d.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, SymInt ignore_index=-100, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nll_loss2d + operator_name: nll_loss2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss2d(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, SymInt ignore_index=-100) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: -100 + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nll_loss2d_forward_out + operator_name: nll_loss2d_forward + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss2d_forward.output(Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index, *, Tensor(a!) output, Tensor(b!) total_weight) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + - dynamic_type: at::Tensor + name: total_weight + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss2d_forward + operator_name: nll_loss2d_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss2d_forward(Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index) -> (Tensor output, Tensor total_weight) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: total_weight + name: total_weight + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss2d_backward_out + operator_name: nll_loss2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index, Tensor total_weight, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: nll_loss2d_backward + operator_name: nll_loss2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nll_loss2d_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight, int reduction, SymInt ignore_index, Tensor total_weight) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ignore_index + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total_weight + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: smooth_l1_loss_out + operator_name: smooth_l1_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::smooth_l1_loss.out(Tensor self, Tensor target, int reduction=Mean, float beta=1.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: beta + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: beta + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: smooth_l1_loss + operator_name: smooth_l1_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::smooth_l1_loss(Tensor self, Tensor target, int reduction=Mean, float beta=1.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: beta + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: beta + type: double + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: smooth_l1_loss_backward_out + operator_name: smooth_l1_loss_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::smooth_l1_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, float beta, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: smooth_l1_loss_backward + operator_name: smooth_l1_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::smooth_l1_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction, float beta) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: huber_loss_out + operator_name: huber_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::huber_loss.out(Tensor self, Tensor target, int reduction=Mean, float delta=1.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: delta + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: delta + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: huber_loss + operator_name: huber_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::huber_loss(Tensor self, Tensor target, int reduction=Mean, float delta=1.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: delta + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: delta + type: double + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: huber_loss_backward_out + operator_name: huber_loss_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::huber_loss_backward.out(Tensor grad_output, Tensor self, Tensor target, int reduction, float delta, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: delta + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: delta + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: huber_loss_backward + operator_name: huber_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::huber_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction, float delta) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: delta + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: delta + type: double + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: soft_margin_loss_out + operator_name: soft_margin_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::soft_margin_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: soft_margin_loss + operator_name: soft_margin_loss + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::soft_margin_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: soft_margin_loss_backward_out + operator_name: soft_margin_loss_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::soft_margin_loss_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, int reduction, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: soft_margin_loss_backward + operator_name: soft_margin_loss_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::soft_margin_loss_backward(Tensor grad_output, Tensor self, Tensor target, int reduction) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: elu_out + operator_name: elu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::elu.out(Tensor self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: elu + operator_name: elu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::elu(Tensor self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: elu_backward_out + operator_name: elu_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::elu_backward.grad_input(Tensor grad_output, Scalar alpha, Scalar scale, Scalar input_scale, bool is_result, Tensor self_or_result, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_result + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self_or_result + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, bool, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_result + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self_or_result + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: elu_backward + operator_name: elu_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::elu_backward(Tensor grad_output, Scalar alpha, Scalar scale, Scalar input_scale, bool is_result, Tensor self_or_result) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_result + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self_or_result + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, bool, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_result + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self_or_result + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: elu_ + operator_name: elu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::elu_(Tensor(a!) self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: scale + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: input_scale + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu_out + operator_name: glu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu.out(Tensor self, int dim=-1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu + operator_name: glu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu(Tensor self, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu_backward_out + operator_name: glu_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu_backward.grad_input(Tensor grad_output, Tensor self, int dim, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu_backward + operator_name: glu_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu_backward(Tensor grad_output, Tensor self, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu_jvp + operator_name: glu_jvp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu_jvp(Tensor glu, Tensor x, Tensor dx, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu_backward_jvp + operator_name: glu_backward_jvp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu_backward_jvp(Tensor grad_x, Tensor grad_glu, Tensor x, Tensor dgrad_glu, Tensor dx, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dgrad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dgrad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardsigmoid_out + operator_name: hardsigmoid + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardsigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardsigmoid + operator_name: hardsigmoid + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardsigmoid(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardsigmoid_ + operator_name: hardsigmoid_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardsigmoid_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardsigmoid_backward_out + operator_name: hardsigmoid_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardsigmoid_backward.grad_input(Tensor grad_output, Tensor self, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardsigmoid_backward + operator_name: hardsigmoid_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardsigmoid_backward(Tensor grad_output, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardtanh_out + operator_name: hardtanh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardtanh.out(Tensor self, Scalar min_val=-1, Scalar max_val=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardtanh + operator_name: hardtanh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardtanh(Tensor self, Scalar min_val=-1, Scalar max_val=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardtanh_backward_out + operator_name: hardtanh_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardtanh_backward.grad_input(Tensor grad_output, Tensor self, Scalar min_val, Scalar max_val, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardtanh_backward + operator_name: hardtanh_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardtanh_backward(Tensor grad_output, Tensor self, Scalar min_val, Scalar max_val) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardtanh_ + operator_name: hardtanh_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardtanh_(Tensor(a!) self, Scalar min_val=-1, Scalar max_val=1) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: -1 + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: -1 + dynamic_type: const at::Scalar & + is_nullable: false + name: min_val + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: max_val + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardswish_out + operator_name: hardswish + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardswish.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardswish + operator_name: hardswish + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardswish(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardswish_ + operator_name: hardswish_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardswish_(Tensor(a!) self) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::Tensor &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardswish_backward + operator_name: hardswish_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardswish_backward(Tensor grad_output, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: leaky_relu_out + operator_name: leaky_relu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::leaky_relu.out(Tensor self, Scalar negative_slope=0.01, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.01 + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.01 + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: leaky_relu + operator_name: leaky_relu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::leaky_relu(Tensor self, Scalar negative_slope=0.01) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.01 + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.01 + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: leaky_relu_backward_out + operator_name: leaky_relu_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::leaky_relu_backward.grad_input(Tensor grad_output, Tensor self, Scalar negative_slope, bool self_is_result, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: leaky_relu_backward + operator_name: leaky_relu_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::leaky_relu_backward(Tensor grad_output, Tensor self, Scalar negative_slope, bool self_is_result) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: leaky_relu_ + operator_name: leaky_relu_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::leaky_relu_(Tensor(a!) self, Scalar negative_slope=0.01) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0.01 + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + default: 0.01 + dynamic_type: const at::Scalar & + is_nullable: false + name: negative_slope + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_sigmoid_out + operator_name: log_sigmoid + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_sigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: log_sigmoid + operator_name: log_sigmoid + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_sigmoid(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: log_sigmoid_forward_out + operator_name: log_sigmoid_forward + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_sigmoid_forward.output(Tensor self, *, Tensor(a!) output, Tensor(b!) buffer) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: buffer + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: buffer + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + - dynamic_type: at::Tensor + name: buffer + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_sigmoid_forward + operator_name: log_sigmoid_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_sigmoid_forward(Tensor self) -> (Tensor output, Tensor buffer) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: buffer + name: buffer + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_sigmoid_backward_out + operator_name: log_sigmoid_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_sigmoid_backward.grad_input(Tensor grad_output, Tensor self, Tensor buffer, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: buffer + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: buffer + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_sigmoid_backward + operator_name: log_sigmoid_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_sigmoid_backward(Tensor grad_output, Tensor self, Tensor buffer) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: buffer + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: buffer + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rrelu_with_noise_out + operator_name: rrelu_with_noise + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rrelu_with_noise.out(Tensor self, Tensor noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rrelu_with_noise + operator_name: rrelu_with_noise + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rrelu_with_noise(Tensor self, Tensor noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rrelu_with_noise_backward + operator_name: rrelu_with_noise_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rrelu_with_noise_backward(Tensor grad_output, Tensor self, Tensor noise, Scalar lower, Scalar upper, bool training, bool self_is_result) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: rrelu_with_noise_ + operator_name: rrelu_with_noise_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::rrelu_with_noise_(Tensor(a!) self, Tensor noise, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator? generator=None) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, c10::optional) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + default: 0.125 + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + default: 0.3333333333333333 + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softplus_out + operator_name: softplus + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::softplus.out(Tensor self, Scalar beta=1, Scalar threshold=20, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + default: 20 + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + default: 20 + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softplus + operator_name: softplus + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::softplus(Tensor self, Scalar beta=1, Scalar threshold=20) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + default: 20 + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + default: 20 + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softplus_backward_out + operator_name: softplus_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::softplus_backward.grad_input(Tensor grad_output, Tensor self, Scalar beta, Scalar threshold, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softplus_backward + operator_name: softplus_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::softplus_backward(Tensor grad_output, Tensor self, Scalar beta, Scalar threshold) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: beta + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: threshold + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softshrink_out + operator_name: softshrink + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::softshrink.out(Tensor self, Scalar lambd=0.5, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softshrink + operator_name: softshrink + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::softshrink(Tensor self, Scalar lambd=0.5) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softshrink_backward_out + operator_name: softshrink_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::softshrink_backward.grad_input(Tensor grad_output, Tensor self, Scalar lambd, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: softshrink_backward + operator_name: softshrink_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::softshrink_backward(Tensor grad_output, Tensor self, Scalar lambd) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lambd + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_avg_pool2d_out + operator_name: adaptive_avg_pool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_avg_pool2d + operator_name: adaptive_avg_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_avg_pool2d(Tensor self, SymInt[2] output_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: mkldnn_adaptive_avg_pool2d + operator_name: mkldnn_adaptive_avg_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_adaptive_avg_pool2d(Tensor self, int[2] output_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_adaptive_avg_pool2d_out + operator_name: mkldnn_adaptive_avg_pool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_adaptive_avg_pool2d.out(Tensor self, int[2] output_size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_adaptive_avg_pool2d_backward + operator_name: mkldnn_adaptive_avg_pool2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_adaptive_avg_pool2d_backward(Tensor grad_output, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _adaptive_avg_pool2d + operator_name: _adaptive_avg_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool2d(Tensor self, SymInt[2] output_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _adaptive_avg_pool2d_backward + operator_name: _adaptive_avg_pool2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool2d_backward(Tensor grad_output, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_avg_pool3d_out + operator_name: adaptive_avg_pool3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_avg_pool3d.out(Tensor self, SymInt[3] output_size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_avg_pool3d + operator_name: adaptive_avg_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_avg_pool3d(Tensor self, SymInt[3] output_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _adaptive_avg_pool3d + operator_name: _adaptive_avg_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool3d(Tensor self, SymInt[3] output_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_avg_pool3d_backward_out + operator_name: adaptive_avg_pool3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_avg_pool3d_backward.grad_input(Tensor grad_output, Tensor self, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _adaptive_avg_pool3d_backward + operator_name: _adaptive_avg_pool3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool3d_backward(Tensor grad_output, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool2d_out + operator_name: adaptive_max_pool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool2d.out(Tensor self, int[2] output_size, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool2d + operator_name: adaptive_max_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool2d(Tensor self, int[2] output_size) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool2d_backward_out + operator_name: adaptive_max_pool2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool2d_backward + operator_name: adaptive_max_pool2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool2d_backward(Tensor grad_output, Tensor self, Tensor indices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool3d_out + operator_name: adaptive_max_pool3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool3d.out(Tensor self, int[3] output_size, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool3d + operator_name: adaptive_max_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool3d(Tensor self, int[3] output_size) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool3d_backward_out + operator_name: adaptive_max_pool3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool3d_backward.grad_input(Tensor grad_output, Tensor self, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: adaptive_max_pool3d_backward + operator_name: adaptive_max_pool3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::adaptive_max_pool3d_backward(Tensor grad_output, Tensor self, Tensor indices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool2d_out + operator_name: avg_pool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::avg_pool2d.out(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(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool2d + operator_name: avg_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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 + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool2d_backward_out + operator_name: avg_pool2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::avg_pool2d_backward.grad_input(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(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool2d_backward + operator_name: avg_pool2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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 + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool3d_out + operator_name: avg_pool3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::avg_pool3d.out(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(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool3d + operator_name: avg_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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 + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool3d_backward_out + operator_name: avg_pool3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::avg_pool3d_backward.grad_input(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, bool ceil_mode, bool count_include_pad, int? divisor_override, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: avg_pool3d_backward + operator_name: avg_pool3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::avg_pool3d_backward(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, bool ceil_mode, bool count_include_pad, int? divisor_override) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: count_include_pad + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: divisor_override + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool2d_out + operator_name: fractional_max_pool2d + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool2d.output(Tensor self, int[2] kernel_size, int[2] output_size, Tensor random_samples, *, Tensor(a!) output, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + - dynamic_type: at::Tensor + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool2d + operator_name: fractional_max_pool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool2d(Tensor self, int[2] kernel_size, int[2] output_size, Tensor random_samples) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool2d_backward_out + operator_name: fractional_max_pool2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool2d_backward.grad_input(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] output_size, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool2d_backward + operator_name: fractional_max_pool2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool2d_backward(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] output_size, Tensor indices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool3d_out + operator_name: fractional_max_pool3d + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool3d.output(Tensor self, int[3] kernel_size, int[3] output_size, Tensor random_samples, *, Tensor(a!) output, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + - dynamic_type: at::Tensor + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool3d + operator_name: fractional_max_pool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool3d(Tensor self, int[3] kernel_size, int[3] output_size, Tensor random_samples) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: random_samples + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool3d_backward_out + operator_name: fractional_max_pool3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool3d_backward.grad_input(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] output_size, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fractional_max_pool3d_backward + operator_name: fractional_max_pool3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fractional_max_pool3d_backward(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] output_size, Tensor indices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool2d_with_indices_out + operator_name: max_pool2d_with_indices + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool2d_with_indices.out(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool2d_with_indices + operator_name: max_pool2d_with_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool2d_with_indices_backward_out + operator_name: max_pool2d_with_indices_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool2d_with_indices_backward.grad_input(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, bool ceil_mode, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool2d_with_indices_backward + operator_name: max_pool2d_with_indices_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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 + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool3d_with_indices_out + operator_name: max_pool3d_with_indices + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool3d_with_indices.out(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: indices + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + - dynamic_type: at::Tensor + name: indices + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool3d_with_indices + operator_name: max_pool3d_with_indices + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::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) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool3d_with_indices_backward_out + operator_name: max_pool3d_with_indices_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool3d_with_indices_backward.grad_input(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, int[3] dilation, bool ceil_mode, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool3d_with_indices_backward + operator_name: max_pool3d_with_indices_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool3d_with_indices_backward(Tensor grad_output, Tensor self, int[3] kernel_size, int[3] stride, int[3] padding, int[3] dilation, bool ceil_mode, Tensor indices) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_unpool2d_out + operator_name: max_unpool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_unpool2d.out(Tensor self, Tensor indices, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_unpool2d + operator_name: max_unpool2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_unpool2d(Tensor self, Tensor indices, SymInt[2] output_size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_unpool3d_out + operator_name: max_unpool3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_unpool3d.out(Tensor self, Tensor indices, SymInt[3] output_size, int[3] stride, int[3] padding, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_unpool3d + operator_name: max_unpool3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_unpool3d(Tensor self, Tensor indices, SymInt[3] output_size, int[3] stride, int[3] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad1d_out + operator_name: reflection_pad1d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad1d.out(Tensor self, SymInt[2] padding, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad1d + operator_name: reflection_pad1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad1d(Tensor self, SymInt[2] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad1d_backward_out + operator_name: reflection_pad1d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad1d_backward.grad_input(Tensor grad_output, Tensor self, SymInt[2] padding, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad1d_backward + operator_name: reflection_pad1d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad1d_backward(Tensor grad_output, Tensor self, SymInt[2] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad2d_out + operator_name: reflection_pad2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad2d.out(Tensor self, SymInt[4] padding, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad2d + operator_name: reflection_pad2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad2d(Tensor self, SymInt[4] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad2d_backward_out + operator_name: reflection_pad2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad2d_backward.grad_input(Tensor grad_output, Tensor self, SymInt[4] padding, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad2d_backward + operator_name: reflection_pad2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad2d_backward(Tensor grad_output, Tensor self, SymInt[4] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad3d_out + operator_name: reflection_pad3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad3d.out(Tensor self, SymInt[6] padding, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad3d + operator_name: reflection_pad3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad3d(Tensor self, SymInt[6] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad3d_backward_out + operator_name: reflection_pad3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad3d_backward.grad_input(Tensor grad_output, Tensor self, SymInt[6] padding, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: reflection_pad3d_backward + operator_name: reflection_pad3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::reflection_pad3d_backward(Tensor grad_output, Tensor self, SymInt[6] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad1d_out + operator_name: replication_pad1d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad1d.out(Tensor self, SymInt[2] padding, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad1d + operator_name: replication_pad1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad1d(Tensor self, SymInt[2] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad1d_backward_out + operator_name: replication_pad1d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad1d_backward.grad_input(Tensor grad_output, Tensor self, SymInt[2] padding, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad1d_backward + operator_name: replication_pad1d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad1d_backward(Tensor grad_output, Tensor self, SymInt[2] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad2d_out + operator_name: replication_pad2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad2d.out(Tensor self, SymInt[4] padding, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad2d + operator_name: replication_pad2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad2d(Tensor self, SymInt[4] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad2d_backward_out + operator_name: replication_pad2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad2d_backward.grad_input(Tensor grad_output, Tensor self, SymInt[4] padding, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad2d_backward + operator_name: replication_pad2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad2d_backward(Tensor grad_output, Tensor self, SymInt[4] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 4 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad3d_out + operator_name: replication_pad3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad3d.out(Tensor self, SymInt[6] padding, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad3d + operator_name: replication_pad3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad3d(Tensor self, SymInt[6] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad3d_backward_out + operator_name: replication_pad3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad3d_backward.grad_input(Tensor grad_output, Tensor self, SymInt[6] padding, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: replication_pad3d_backward + operator_name: replication_pad3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::replication_pad3d_backward(Tensor grad_output, Tensor self, SymInt[6] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 6 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _pad_circular + operator_name: _pad_circular + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pad_circular(Tensor self, SymInt[] pad) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _pad_enum + operator_name: _pad_enum + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pad_enum(Tensor self, SymInt[] pad, int mode, float? value=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: value + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: value + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: pad + operator_name: pad + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pad(Tensor self, SymInt[] pad, str mode="constant", float? value=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + default: '"constant"' + dynamic_type: c10::string_view + is_nullable: false + name: mode + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: value + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::string_view, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + default: '"constant"' + dynamic_type: c10::string_view + is_nullable: false + name: mode + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: value + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_linear1d + operator_name: upsample_linear1d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_linear1d.vec(Tensor input, SymInt[]? output_size, bool align_corners, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_bilinear2d + operator_name: upsample_bilinear2d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bilinear2d.vec(Tensor input, SymInt[]? output_size, bool align_corners, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _upsample_bilinear2d_aa + operator_name: _upsample_bilinear2d_aa + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bilinear2d_aa.vec(Tensor input, SymInt[]? output_size, bool align_corners, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_trilinear3d + operator_name: upsample_trilinear3d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_trilinear3d.vec(Tensor input, SymInt[]? output_size, bool align_corners, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_bicubic2d + operator_name: upsample_bicubic2d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bicubic2d.vec(Tensor input, SymInt[]? output_size, bool align_corners, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _upsample_bicubic2d_aa + operator_name: _upsample_bicubic2d_aa + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bicubic2d_aa.vec(Tensor input, SymInt[]? output_size, bool align_corners, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, bool, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_nearest1d + operator_name: upsample_nearest1d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest1d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _upsample_nearest_exact1d + operator_name: _upsample_nearest_exact1d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact1d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_nearest2d + operator_name: upsample_nearest2d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest2d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _upsample_nearest_exact2d + operator_name: _upsample_nearest_exact2d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact2d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_nearest3d + operator_name: upsample_nearest3d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest3d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _upsample_nearest_exact3d + operator_name: _upsample_nearest_exact3d + overload_name: vec + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact3d.vec(Tensor input, SymInt[]? output_size, float[]? scale_factors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: scale_factors + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: upsample_linear1d_out + operator_name: upsample_linear1d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_linear1d.out(Tensor self, SymInt[1] output_size, bool align_corners, float? scales=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_linear1d + operator_name: upsample_linear1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_linear1d(Tensor self, SymInt[1] output_size, bool align_corners, float? scales=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_linear1d_backward_out + operator_name: upsample_linear1d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_linear1d_backward.grad_input(Tensor grad_output, SymInt[1] output_size, SymInt[3] input_size, bool align_corners, float? scales=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_linear1d_backward + operator_name: upsample_linear1d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_linear1d_backward(Tensor grad_output, SymInt[1] output_size, SymInt[3] input_size, bool align_corners, float? scales=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bilinear2d_out + operator_name: upsample_bilinear2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bilinear2d.out(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bilinear2d + operator_name: upsample_bilinear2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bilinear2d(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bilinear2d_backward_out + operator_name: upsample_bilinear2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bilinear2d_backward.grad_input(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bilinear2d_backward + operator_name: upsample_bilinear2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bilinear2d_backward(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bilinear2d_aa_out + operator_name: _upsample_bilinear2d_aa + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bilinear2d_aa.out(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bilinear2d_aa + operator_name: _upsample_bilinear2d_aa + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bilinear2d_aa(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bilinear2d_aa_backward_out + operator_name: _upsample_bilinear2d_aa_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bilinear2d_aa_backward.grad_input(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bilinear2d_aa_backward + operator_name: _upsample_bilinear2d_aa_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bilinear2d_aa_backward(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bicubic2d_out + operator_name: upsample_bicubic2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bicubic2d.out(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bicubic2d + operator_name: upsample_bicubic2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bicubic2d(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bicubic2d_backward_out + operator_name: upsample_bicubic2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bicubic2d_backward.grad_input(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_bicubic2d_backward + operator_name: upsample_bicubic2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_bicubic2d_backward(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bicubic2d_aa_out + operator_name: _upsample_bicubic2d_aa + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bicubic2d_aa.out(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bicubic2d_aa + operator_name: _upsample_bicubic2d_aa + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bicubic2d_aa(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bicubic2d_aa_backward_out + operator_name: _upsample_bicubic2d_aa_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bicubic2d_aa_backward.grad_input(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_bicubic2d_aa_backward + operator_name: _upsample_bicubic2d_aa_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_bicubic2d_aa_backward(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_trilinear3d_out + operator_name: upsample_trilinear3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_trilinear3d.out(Tensor self, SymInt[3] output_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_trilinear3d + operator_name: upsample_trilinear3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_trilinear3d(Tensor self, SymInt[3] output_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_trilinear3d_backward_out + operator_name: upsample_trilinear3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_trilinear3d_backward.grad_input(Tensor grad_output, SymInt[3] output_size, SymInt[5] input_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_trilinear3d_backward + operator_name: upsample_trilinear3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_trilinear3d_backward(Tensor grad_output, SymInt[3] output_size, SymInt[5] input_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, bool, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest1d_out + operator_name: upsample_nearest1d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest1d.out(Tensor self, SymInt[1] output_size, float? scales=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact1d_out + operator_name: _upsample_nearest_exact1d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact1d.out(Tensor self, SymInt[1] output_size, float? scales=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest1d + operator_name: upsample_nearest1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest1d(Tensor self, SymInt[1] output_size, float? scales=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact1d + operator_name: _upsample_nearest_exact1d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact1d(Tensor self, SymInt[1] output_size, float? scales=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest1d_backward_out + operator_name: upsample_nearest1d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest1d_backward.grad_input(Tensor grad_output, SymInt[1] output_size, SymInt[3] input_size, float? scales=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact1d_backward_out + operator_name: _upsample_nearest_exact1d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact1d_backward.grad_input(Tensor grad_output, SymInt[1] output_size, SymInt[3] input_size, float? scales=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest1d_backward + operator_name: upsample_nearest1d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest1d_backward(Tensor grad_output, SymInt[1] output_size, SymInt[3] input_size, float? scales=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact1d_backward + operator_name: _upsample_nearest_exact1d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact1d_backward(Tensor grad_output, SymInt[1] output_size, SymInt[3] input_size, float? scales=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest2d_out + operator_name: upsample_nearest2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest2d.out(Tensor self, SymInt[2] output_size, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact2d_out + operator_name: _upsample_nearest_exact2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact2d.out(Tensor self, SymInt[2] output_size, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest2d + operator_name: upsample_nearest2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest2d(Tensor self, SymInt[2] output_size, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact2d + operator_name: _upsample_nearest_exact2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact2d(Tensor self, SymInt[2] output_size, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest2d_backward_out + operator_name: upsample_nearest2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest2d_backward.grad_input(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact2d_backward_out + operator_name: _upsample_nearest_exact2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact2d_backward.grad_input(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest2d_backward + operator_name: upsample_nearest2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest2d_backward(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact2d_backward + operator_name: _upsample_nearest_exact2d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact2d_backward(Tensor grad_output, SymInt[2] output_size, SymInt[4] input_size, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 4 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest3d_out + operator_name: upsample_nearest3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest3d.out(Tensor self, SymInt[3] output_size, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact3d_out + operator_name: _upsample_nearest_exact3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact3d.out(Tensor self, SymInt[3] output_size, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest3d + operator_name: upsample_nearest3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest3d(Tensor self, SymInt[3] output_size, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact3d + operator_name: _upsample_nearest_exact3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact3d(Tensor self, SymInt[3] output_size, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest3d_backward_out + operator_name: upsample_nearest3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest3d_backward.grad_input(Tensor grad_output, SymInt[3] output_size, SymInt[5] input_size, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact3d_backward_out + operator_name: _upsample_nearest_exact3d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact3d_backward.grad_input(Tensor grad_output, SymInt[3] output_size, SymInt[5] input_size, float? scales_d=None, float? scales_h=None, float? scales_w=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: upsample_nearest3d_backward + operator_name: upsample_nearest3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::upsample_nearest3d_backward(Tensor grad_output, SymInt[3] output_size, SymInt[5] input_size, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _upsample_nearest_exact3d_backward + operator_name: _upsample_nearest_exact3d_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_upsample_nearest_exact3d_backward(Tensor grad_output, SymInt[3] output_size, SymInt[5] input_size, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + size: 5 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_d + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_h + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: scales_w + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sigmoid_backward_out + operator_name: sigmoid_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::sigmoid_backward.grad_input(Tensor grad_output, Tensor output, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: sigmoid_backward + operator_name: sigmoid_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sigmoid_backward(Tensor grad_output, Tensor output) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logit_backward_out + operator_name: logit_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::logit_backward.grad_input(Tensor grad_output, Tensor self, float? eps=None, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: logit_backward + operator_name: logit_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logit_backward(Tensor grad_output, Tensor self, float? eps=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tanh_backward_out + operator_name: tanh_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::tanh_backward.grad_input(Tensor grad_output, Tensor output, *, Tensor(a!) grad_input) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: tanh_backward + operator_name: tanh_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::tanh_backward(Tensor grad_output, Tensor output) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_transpose2d_out + operator_name: slow_conv_transpose2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, int[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_transpose2d + operator_name: slow_conv_transpose2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_transpose2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, int[2] dilation=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_transpose3d_out + operator_name: slow_conv_transpose3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_transpose3d.out(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0, SymInt[3] output_padding=0, int[3] dilation=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_transpose3d + operator_name: slow_conv_transpose3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_transpose3d(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0, SymInt[3] output_padding=0, int[3] dilation=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: thnn_conv2d_out + operator_name: thnn_conv2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::thnn_conv2d.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: thnn_conv2d + operator_name: thnn_conv2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::thnn_conv2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, int[2] padding=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _slow_conv2d_forward_out + operator_name: _slow_conv2d_forward + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::_slow_conv2d_forward.output(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, int[2] padding, *, Tensor(a!) output) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _slow_conv2d_forward + operator_name: _slow_conv2d_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_slow_conv2d_forward(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, int[2] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _slow_conv2d_backward_out + operator_name: _slow_conv2d_backward + overload_name: grad_input + manual_kernel_registration: false + category_override: '' + schema_string: aten::_slow_conv2d_backward.grad_input(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, *, Tensor(a!) grad_input, Tensor(b!) grad_weight, Tensor(c!) grad_bias) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: grad_weight + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: grad_bias + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: grad_input + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: grad_weight + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: grad_bias + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: grad_input + type: at::Tensor & + - dynamic_type: at::Tensor + name: grad_weight + type: at::Tensor & + - dynamic_type: at::Tensor + name: grad_bias + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _slow_conv2d_backward + operator_name: _slow_conv2d_backward + overload_name: output_mask + manual_kernel_registration: false + category_override: '' + schema_string: aten::_slow_conv2d_backward.output_mask(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, bool[3] output_mask) -> (Tensor grad_input, Tensor grad_weight, Tensor grad_bias) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, ::std::array) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + field_name: grad_input + name: grad_input + type: at::Tensor + - dynamic_type: at::Tensor + field_name: grad_weight + name: grad_weight + type: at::Tensor + - dynamic_type: at::Tensor + field_name: grad_bias + name: grad_bias + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _conv_depthwise2d_out + operator_name: _conv_depthwise2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_conv_depthwise2d.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, SymInt[2] padding, int[2] dilation, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _conv_depthwise2d + operator_name: _conv_depthwise2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_conv_depthwise2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias, int[2] stride, SymInt[2] padding, int[2] dilation) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: conv_depthwise3d + operator_name: conv_depthwise3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_depthwise3d(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias, int[3] stride, SymInt[3] padding, int[3] dilation) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv3d_out + operator_name: slow_conv3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv3d.out(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: slow_conv3d + operator_name: slow_conv3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv3d(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: slow_conv3d_forward_out + operator_name: slow_conv3d_forward + overload_name: output + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv3d_forward.output(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias, int[3] stride, SymInt[3] padding, *, Tensor(a!) output) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: output + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: output + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv3d_forward + operator_name: slow_conv3d_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv3d_forward(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias, int[3] stride, SymInt[3] padding) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_dilated2d + operator_name: slow_conv_dilated2d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_dilated2d(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, SymInt[2] padding=0, int[2] dilation=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_dilated3d + operator_name: slow_conv_dilated3d + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_dilated3d(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0, int[3] dilation=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: col2im_out + operator_name: col2im + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::col2im.out(Tensor self, SymInt[2] output_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: col2im + operator_name: col2im + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::col2im(Tensor self, SymInt[2] output_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: column_stack + operator_name: column_stack + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::column_stack(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: column_stack_out + operator_name: column_stack + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::column_stack.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: im2col_out + operator_name: im2col + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::im2col.out(Tensor self, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: im2col + operator_name: im2col + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::im2col(Tensor self, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isfinite + operator_name: isfinite + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::isfinite(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: true +- name: isinf + operator_name: isinf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::isinf(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: record_stream + operator_name: record_stream + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::record_stream(Tensor(a!) self, Stream s) -> () + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Stream + is_nullable: false + name: s + type: at::Stream + schema_order_cpp_signature: void (at::Tensor &, at::Stream) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: at::Stream + is_nullable: false + name: s + type: at::Stream + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isposinf + operator_name: isposinf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::isposinf(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isposinf_out + operator_name: isposinf + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::isposinf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isneginf + operator_name: isneginf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::isneginf(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: isneginf_out + operator_name: isneginf + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::isneginf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _add_batch_dim + operator_name: _add_batch_dim + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_add_batch_dim(Tensor self, int batch_dim, int level) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: batch_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: batch_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _remove_batch_dim + operator_name: _remove_batch_dim + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_remove_batch_dim(Tensor self, int level, int batch_size, int out_dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: batch_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: out_dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: batch_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: out_dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_entr + operator_name: special_entr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_entr(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_entr_out + operator_name: special_entr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_entr.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_ndtri + operator_name: special_ndtri + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_ndtri(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_ndtri_out + operator_name: special_ndtri + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_ndtri.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_log_ndtr + operator_name: special_log_ndtr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_log_ndtr(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_log_ndtr_out + operator_name: special_log_ndtr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_log_ndtr.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_expm1 + operator_name: special_expm1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_expm1(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_expm1_out + operator_name: special_expm1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_expm1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_exp2 + operator_name: special_exp2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_exp2(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_exp2_out + operator_name: special_exp2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_exp2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_psi + operator_name: special_psi + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_psi(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_psi_out + operator_name: special_psi + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_psi.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_digamma + operator_name: special_digamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_digamma(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_digamma_out + operator_name: special_digamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_digamma.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_gammaln + operator_name: special_gammaln + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_gammaln(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_gammaln_out + operator_name: special_gammaln + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_gammaln.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_erf + operator_name: special_erf + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erf(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_erf_out + operator_name: special_erf + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_erfc + operator_name: special_erfc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erfc(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_erfc_out + operator_name: special_erfc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erfc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_erfcx + operator_name: special_erfcx + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erfcx(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_erfcx_out + operator_name: special_erfcx + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erfcx.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_erfinv + operator_name: special_erfinv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erfinv(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_erfinv_out + operator_name: special_erfinv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_erfinv.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_ndtr + operator_name: special_ndtr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_ndtr(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_ndtr_out + operator_name: special_ndtr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_ndtr.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_xlog1py + operator_name: special_xlog1py + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlog1py(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_xlog1py + operator_name: special_xlog1py + overload_name: self_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlog1py.self_scalar(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_xlog1py + operator_name: special_xlog1py + overload_name: other_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlog1py.other_scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_xlog1py_out + operator_name: special_xlog1py + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlog1py.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_xlog1py_out + operator_name: special_xlog1py + overload_name: self_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlog1py.self_scalar_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_xlog1py_out + operator_name: special_xlog1py + overload_name: other_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlog1py.other_scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_xlogy + operator_name: special_xlogy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlogy(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_xlogy + operator_name: special_xlogy + overload_name: self_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlogy.self_scalar(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_xlogy + operator_name: special_xlogy + overload_name: other_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlogy.other_scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_xlogy_out + operator_name: special_xlogy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlogy.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_xlogy_out + operator_name: special_xlogy + overload_name: self_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlogy.self_scalar_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_xlogy_out + operator_name: special_xlogy + overload_name: other_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_xlogy.other_scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_zeta + operator_name: special_zeta + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_zeta(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_zeta + operator_name: special_zeta + overload_name: self_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_zeta.self_scalar(Scalar self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_zeta + operator_name: special_zeta + overload_name: other_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_zeta.other_scalar(Tensor self, Scalar other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_zeta_out + operator_name: special_zeta + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_zeta.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_zeta_out + operator_name: special_zeta + overload_name: self_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_zeta.self_scalar_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_zeta_out + operator_name: special_zeta + overload_name: other_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_zeta.other_scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_i0 + operator_name: special_i0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i0(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_i0_out + operator_name: special_i0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_i0e + operator_name: special_i0e + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i0e(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_i0e_out + operator_name: special_i0e + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i0e.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_i1 + operator_name: special_i1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i1(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_i1_out + operator_name: special_i1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_i1e + operator_name: special_i1e + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i1e(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_i1e_out + operator_name: special_i1e + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_i1e.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_logit + operator_name: special_logit + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_logit(Tensor self, float? eps=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_logit_out + operator_name: special_logit + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_logit.out(Tensor self, float? eps=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: eps + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_polygamma + operator_name: special_polygamma + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_polygamma(int n, Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_polygamma_out + operator_name: special_polygamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_polygamma.out(int n, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_logsumexp + operator_name: special_logsumexp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_logsumexp(Tensor self, int[1] dim, bool keepdim=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_logsumexp_out + operator_name: special_logsumexp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_logsumexp.out(Tensor self, int[1] dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_expit + operator_name: special_expit + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_expit(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_expit_out + operator_name: special_expit + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_expit.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_sinc + operator_name: special_sinc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_sinc(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_sinc_out + operator_name: special_sinc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_sinc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_round + operator_name: special_round + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_round(Tensor self, *, int decimals=0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_round_out + operator_name: special_round + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_round.out(Tensor self, *, int decimals=0, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: decimals + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_log1p + operator_name: special_log1p + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_log1p(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_log1p_out + operator_name: special_log1p + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_log1p.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_log_softmax + operator_name: special_log_softmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_log_softmax(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_gammainc_out + operator_name: special_gammainc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_gammainc.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_gammainc + operator_name: special_gammainc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_gammainc(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_gammaincc_out + operator_name: special_gammaincc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_gammaincc.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_gammaincc + operator_name: special_gammaincc + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_gammaincc(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_multigammaln + operator_name: special_multigammaln + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_multigammaln(Tensor self, int p) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_multigammaln_out + operator_name: special_multigammaln + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_multigammaln.out(Tensor self, int p, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: p + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_softmax + operator_name: special_softmax + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_softmax(Tensor self, int dim, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_fft + operator_name: fft_fft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fft(Tensor self, SymInt? n=None, int dim=-1, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_fft_out + operator_name: fft_fft + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fft.out(Tensor self, SymInt? n=None, int dim=-1, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ifft + operator_name: fft_ifft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ifft(Tensor self, SymInt? n=None, int dim=-1, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ifft_out + operator_name: fft_ifft + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ifft.out(Tensor self, SymInt? n=None, int dim=-1, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_rfft + operator_name: fft_rfft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfft(Tensor self, SymInt? n=None, int dim=-1, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_rfft_out + operator_name: fft_rfft + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfft.out(Tensor self, SymInt? n=None, int dim=-1, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_irfft + operator_name: fft_irfft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_irfft(Tensor self, SymInt? n=None, int dim=-1, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_irfft_out + operator_name: fft_irfft + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_irfft.out(Tensor self, SymInt? n=None, int dim=-1, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_hfft + operator_name: fft_hfft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_hfft(Tensor self, SymInt? n=None, int dim=-1, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_hfft_out + operator_name: fft_hfft + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_hfft.out(Tensor self, SymInt? n=None, int dim=-1, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ihfft + operator_name: fft_ihfft + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ihfft(Tensor self, SymInt? n=None, int dim=-1, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ihfft_out + operator_name: fft_ihfft + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ihfft.out(Tensor self, SymInt? n=None, int dim=-1, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: n + type: c10::optional + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_fft2 + operator_name: fft_fft2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fft2(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_fft2_out + operator_name: fft_fft2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fft2.out(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ifft2 + operator_name: fft_ifft2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ifft2(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ifft2_out + operator_name: fft_ifft2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ifft2.out(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_rfft2 + operator_name: fft_rfft2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfft2(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_rfft2_out + operator_name: fft_rfft2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfft2.out(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_irfft2 + operator_name: fft_irfft2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_irfft2(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_irfft2_out + operator_name: fft_irfft2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_irfft2.out(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_hfft2 + operator_name: fft_hfft2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_hfft2(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_hfft2_out + operator_name: fft_hfft2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_hfft2.out(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ihfft2 + operator_name: fft_ihfft2 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ihfft2(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ihfft2_out + operator_name: fft_ihfft2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ihfft2.out(Tensor self, SymInt[1]? s=None, int[1] dim=[-2,-1], str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_fftn + operator_name: fft_fftn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fftn(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_fftn_out + operator_name: fft_fftn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fftn.out(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ifftn + operator_name: fft_ifftn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ifftn(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ifftn_out + operator_name: fft_ifftn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ifftn.out(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_rfftn + operator_name: fft_rfftn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfftn(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_rfftn_out + operator_name: fft_rfftn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfftn.out(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_irfftn + operator_name: fft_irfftn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_irfftn(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_irfftn_out + operator_name: fft_irfftn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_irfftn.out(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_hfftn + operator_name: fft_hfftn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_hfftn(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_hfftn_out + operator_name: fft_hfftn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_hfftn.out(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ihfftn + operator_name: fft_ihfftn + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ihfftn(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ihfftn_out + operator_name: fft_ihfftn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ihfftn.out(Tensor self, SymInt[1]? s=None, int[1]? dim=None, str? norm=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::OptionalIntArrayRef, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: s + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + name: norm + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_fftfreq + operator_name: fft_fftfreq + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fftfreq(int n, float d=1.0, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, double, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fft_fftfreq_out + operator_name: fft_fftfreq + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fftfreq.out(int n, float d=1.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + schema_order_cpp_signature: at::Tensor & (int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fft_rfftfreq + operator_name: fft_rfftfreq + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfftfreq(int n, float d=1.0, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + - annotation: null + default: '{}' + dynamic_type: at::TensorOptions + is_nullable: false + kwarg_only: true + name: options + type: at::TensorOptions + schema_order_cpp_signature: at::Tensor (int64_t, double, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + kwarg_only: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: true + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fft_rfftfreq_out + operator_name: fft_rfftfreq + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_rfftfreq.out(int n, float d=1.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + schema_order_cpp_signature: at::Tensor & (int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: d + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: fft_fftshift + operator_name: fft_fftshift + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_fftshift(Tensor self, int[1]? dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: fft_ifftshift + operator_name: fft_ifftshift + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::fft_ifftshift(Tensor self, int[1]? dim=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: fft + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_cholesky_ex + operator_name: linalg_cholesky_ex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cholesky_ex(Tensor self, *, bool upper=False, bool check_errors=False) -> (Tensor L, Tensor info) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: L + name: L + type: at::Tensor + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_cholesky_ex_out + operator_name: linalg_cholesky_ex + overload_name: L + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cholesky_ex.L(Tensor self, *, bool upper=False, bool check_errors=False, Tensor(a!) L, Tensor(b!) info) -> (Tensor(a!) L, Tensor(b!) info) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: L + is_nullable: false + name: L + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: L + is_nullable: false + name: L + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: L + name: L + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_cholesky + operator_name: linalg_cholesky + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cholesky(Tensor self, *, bool upper=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_cholesky_out + operator_name: linalg_cholesky + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cholesky.out(Tensor self, *, bool upper=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: upper + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_cross + operator_name: linalg_cross + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cross(Tensor self, Tensor other, *, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_cross_out + operator_name: linalg_cross + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cross.out(Tensor self, Tensor other, *, int dim=-1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lu_factor + operator_name: linalg_lu_factor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu_factor(Tensor A, *, bool pivot=True) -> (Tensor LU, Tensor pivots) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_lu_factor_out + operator_name: linalg_lu_factor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu_factor.out(Tensor A, *, bool pivot=True, Tensor(a!) LU, Tensor(b!) pivots) -> (Tensor(a!) LU, Tensor(b!) pivots) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_lu_factor_ex + operator_name: linalg_lu_factor_ex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu_factor_ex(Tensor A, *, bool pivot=True, bool check_errors=False) -> (Tensor LU, Tensor pivots, Tensor info) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lu_factor_ex_out + operator_name: linalg_lu_factor_ex + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu_factor_ex.out(Tensor A, *, bool pivot=True, bool check_errors=False, Tensor(a!) LU, Tensor(b!) pivots, Tensor(c!) info) -> (Tensor(a!) LU, Tensor(b!) pivots, Tensor(c!) info) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lu + operator_name: linalg_lu + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu(Tensor A, *, bool pivot=True) -> (Tensor P, Tensor L, Tensor U) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: P + name: P + type: at::Tensor + - dynamic_type: at::Tensor + field_name: L + name: L + type: at::Tensor + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lu_out + operator_name: linalg_lu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu.out(Tensor A, *, bool pivot=True, Tensor(a!) P, Tensor(b!) L, Tensor(c!) U) -> (Tensor(a!) P, Tensor(b!) L, Tensor(c!) U) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: P + is_nullable: false + name: P + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: L + is_nullable: false + name: L + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: pivot + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: P + is_nullable: false + name: P + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: L + is_nullable: false + name: L + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: P + name: P + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: L + name: L + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lu_solve + operator_name: linalg_lu_solve + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu_solve(Tensor LU, Tensor pivots, Tensor B, *, bool left=True, bool adjoint=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: adjoint + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: adjoint + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lu_solve_out + operator_name: linalg_lu_solve + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lu_solve.out(Tensor LU, Tensor pivots, Tensor B, *, bool left=True, bool adjoint=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: adjoint + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LU + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: adjoint + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_det + operator_name: _linalg_det + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_det(Tensor A) -> (Tensor result, Tensor LU, Tensor pivots) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: result + name: result + type: at::Tensor + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_det_out + operator_name: _linalg_det + overload_name: result + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_det.result(Tensor A, *, Tensor(a!) result, Tensor(b!) LU, Tensor(c!) pivots) -> (Tensor(a!) result, Tensor(b!) LU, Tensor(c!) pivots) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: result + is_nullable: false + name: result + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: result + is_nullable: false + name: result + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: result + name: result + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_det + operator_name: linalg_det + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_det(Tensor A) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_det_out + operator_name: linalg_det + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_det.out(Tensor A, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: det + operator_name: det + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::det(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_ldl_factor_ex + operator_name: linalg_ldl_factor_ex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_ldl_factor_ex(Tensor self, *, bool hermitian=False, bool check_errors=False) -> (Tensor LD, Tensor pivots, Tensor info) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LD + name: LD + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_ldl_factor_ex_out + operator_name: linalg_ldl_factor_ex + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_ldl_factor_ex.out(Tensor self, *, bool hermitian=False, bool check_errors=False, Tensor(a!) LD, Tensor(b!) pivots, Tensor(c!) info) -> (Tensor(a!) LD, Tensor(b!) pivots, Tensor(c!) info) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LD + is_nullable: false + name: LD + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LD + is_nullable: false + name: LD + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LD + name: LD + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_ldl_factor + operator_name: linalg_ldl_factor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_ldl_factor(Tensor self, *, bool hermitian=False) -> (Tensor LD, Tensor pivots) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LD + name: LD + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_ldl_factor_out + operator_name: linalg_ldl_factor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_ldl_factor.out(Tensor self, *, bool hermitian=False, Tensor(a!) LD, Tensor(b!) pivots) -> (Tensor(a!) LD, Tensor(b!) pivots) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LD + is_nullable: false + name: LD + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: LD + is_nullable: false + name: LD + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: LD + name: LD + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_ldl_solve + operator_name: linalg_ldl_solve + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_ldl_solve(Tensor LD, Tensor pivots, Tensor B, *, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LD + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LD + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_ldl_solve_out + operator_name: linalg_ldl_solve + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_ldl_solve.out(Tensor LD, Tensor pivots, Tensor B, *, bool hermitian=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LD + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: LD + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pivots + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lstsq + operator_name: linalg_lstsq + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lstsq(Tensor self, Tensor b, float? rcond=None, *, str? driver=None) -> (Tensor solution, Tensor residuals, Tensor rank, Tensor singular_values) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: rcond + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: rcond + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: solution + name: solution + type: at::Tensor + - dynamic_type: at::Tensor + field_name: residuals + name: residuals + type: at::Tensor + - dynamic_type: at::Tensor + field_name: rank + name: rank + type: at::Tensor + - dynamic_type: at::Tensor + field_name: singular_values + name: singular_values + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_lstsq_out + operator_name: linalg_lstsq + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_lstsq.out(Tensor self, Tensor b, float? rcond=None, *, str? driver=None, Tensor(a!) solution, Tensor(b!) residuals, Tensor(c!) rank, Tensor(d!) singular_values) -> (Tensor(a!) solution, Tensor(b!) residuals, Tensor(c!) rank, Tensor(d!) singular_values) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: solution + is_nullable: false + name: solution + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: residuals + is_nullable: false + name: residuals + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: rank + is_nullable: false + name: rank + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + field_name: singular_values + is_nullable: false + name: singular_values + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: rcond + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: b + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + name: rcond + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: solution + is_nullable: false + name: solution + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: residuals + is_nullable: false + name: residuals + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: rank + is_nullable: false + name: rank + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + field_name: singular_values + is_nullable: false + name: singular_values + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: solution + name: solution + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: residuals + name: residuals + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: rank + name: rank + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: singular_values + name: singular_values + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_matmul + operator_name: linalg_matmul + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matmul(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matmul_out + operator_name: linalg_matmul + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matmul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_vecdot + operator_name: linalg_vecdot + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_vecdot(Tensor x, Tensor y, *, int dim=-1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_vecdot_out + operator_name: linalg_vecdot + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_vecdot.out(Tensor x, Tensor y, *, int dim=-1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: y + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_exp + operator_name: linalg_matrix_exp + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_exp(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_slogdet + operator_name: _linalg_slogdet + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_slogdet(Tensor A) -> (Tensor sign, Tensor logabsdet, Tensor LU, Tensor pivots) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: sign + name: sign + type: at::Tensor + - dynamic_type: at::Tensor + field_name: logabsdet + name: logabsdet + type: at::Tensor + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_slogdet_out + operator_name: _linalg_slogdet + overload_name: sign + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_slogdet.sign(Tensor A, *, Tensor(a!) sign, Tensor(b!) logabsdet, Tensor(c!) LU, Tensor(d!) pivots) -> (Tensor(a!) sign, Tensor(b!) logabsdet, Tensor(c!) LU, Tensor(d!) pivots) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: sign + is_nullable: false + name: sign + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: logabsdet + is_nullable: false + name: logabsdet + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: sign + is_nullable: false + name: sign + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: logabsdet + is_nullable: false + name: logabsdet + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: sign + name: sign + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: logabsdet + name: logabsdet + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_slogdet + operator_name: linalg_slogdet + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_slogdet(Tensor A) -> (Tensor sign, Tensor logabsdet) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: sign + name: sign + type: at::Tensor + - dynamic_type: at::Tensor + field_name: logabsdet + name: logabsdet + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_slogdet_out + operator_name: linalg_slogdet + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_slogdet.out(Tensor A, *, Tensor(a!) sign, Tensor(b!) logabsdet) -> (Tensor(a!) sign, Tensor(b!) logabsdet) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: sign + is_nullable: false + name: sign + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: logabsdet + is_nullable: false + name: logabsdet + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: sign + is_nullable: false + name: sign + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: logabsdet + is_nullable: false + name: logabsdet + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: sign + name: sign + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: logabsdet + name: logabsdet + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: slogdet + operator_name: slogdet + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::slogdet(Tensor self) -> (Tensor sign, Tensor logabsdet) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: sign + name: sign + type: at::Tensor + - dynamic_type: at::Tensor + field_name: logabsdet + name: logabsdet + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: slogdet_out + operator_name: slogdet + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slogdet.out(Tensor self, *, Tensor(a!) sign, Tensor(b!) logabsdet) -> (Tensor(a!) sign, Tensor(b!) logabsdet) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: sign + is_nullable: false + name: sign + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: logabsdet + is_nullable: false + name: logabsdet + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: sign + is_nullable: false + name: sign + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: logabsdet + is_nullable: false + name: logabsdet + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: sign + name: sign + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: logabsdet + name: logabsdet + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: logdet + operator_name: logdet + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::logdet(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_eig + operator_name: linalg_eig + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eig(Tensor self) -> (Tensor eigenvalues, Tensor eigenvectors) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: eigenvalues + name: eigenvalues + type: at::Tensor + - dynamic_type: at::Tensor + field_name: eigenvectors + name: eigenvectors + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_eig_out + operator_name: linalg_eig + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eig.out(Tensor self, *, Tensor(a!) eigenvalues, Tensor(b!) eigenvectors) -> (Tensor(a!) eigenvalues, Tensor(b!) eigenvectors) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: eigenvalues + is_nullable: false + name: eigenvalues + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: eigenvectors + is_nullable: false + name: eigenvectors + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: eigenvalues + is_nullable: false + name: eigenvalues + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: eigenvectors + is_nullable: false + name: eigenvectors + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: eigenvalues + name: eigenvalues + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: eigenvectors + name: eigenvectors + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_eigvals + operator_name: linalg_eigvals + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eigvals(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_eigvals_out + operator_name: linalg_eigvals + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eigvals.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _linalg_eigh + operator_name: _linalg_eigh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_eigh(Tensor A, str UPLO="L", bool compute_v=True) -> (Tensor eigenvalues, Tensor eigenvectors) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_v + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::string_view, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_v + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: eigenvalues + name: eigenvalues + type: at::Tensor + - dynamic_type: at::Tensor + field_name: eigenvectors + name: eigenvectors + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_eigh_out + operator_name: _linalg_eigh + overload_name: eigenvalues + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_eigh.eigenvalues(Tensor A, str UPLO="L", bool compute_v=True, *, Tensor(a!) eigenvalues, Tensor(b!) eigenvectors) -> (Tensor(a!) eigenvalues, Tensor(b!) eigenvectors) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: eigenvalues + is_nullable: false + name: eigenvalues + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: eigenvectors + is_nullable: false + name: eigenvectors + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_v + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::string_view, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_v + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: eigenvalues + is_nullable: false + name: eigenvalues + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: eigenvectors + is_nullable: false + name: eigenvectors + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: eigenvalues + name: eigenvalues + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: eigenvectors + name: eigenvectors + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_eigh + operator_name: linalg_eigh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eigh(Tensor self, str UPLO="L") -> (Tensor eigenvalues, Tensor eigenvectors) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: eigenvalues + name: eigenvalues + type: at::Tensor + - dynamic_type: at::Tensor + field_name: eigenvectors + name: eigenvectors + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_eigh_out + operator_name: linalg_eigh + overload_name: eigvals + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eigh.eigvals(Tensor self, str UPLO="L", *, Tensor(a!) eigvals, Tensor(b!) eigvecs) -> (Tensor(a!) eigenvalues, Tensor(b!) eigenvectors) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: eigenvalues + is_nullable: false + name: eigvals + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: eigenvectors + is_nullable: false + name: eigvecs + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::string_view, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: eigenvalues + is_nullable: false + name: eigvals + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: eigenvectors + is_nullable: false + name: eigvecs + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: eigenvalues + name: eigvals + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: eigenvectors + name: eigvecs + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_eigvalsh + operator_name: linalg_eigvalsh + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eigvalsh(Tensor self, str UPLO="L") -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_eigvalsh_out + operator_name: linalg_eigvalsh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_eigvalsh.out(Tensor self, str UPLO="L", *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"L"' + dynamic_type: c10::string_view + is_nullable: false + name: UPLO + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_householder_product + operator_name: linalg_householder_product + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_householder_product(Tensor input, Tensor tau) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tau + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tau + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_householder_product_out + operator_name: linalg_householder_product + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_householder_product.out(Tensor input, Tensor tau, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tau + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tau + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_inv_ex + operator_name: linalg_inv_ex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_inv_ex(Tensor A, *, bool check_errors=False) -> (Tensor inverse, Tensor info) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: inverse + name: inverse + type: at::Tensor + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_inv_ex_out + operator_name: linalg_inv_ex + overload_name: inverse + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_inv_ex.inverse(Tensor A, *, bool check_errors=False, Tensor(a!) inverse, Tensor(b!) info) -> (Tensor(a!) inverse, Tensor(b!) info) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: inverse + is_nullable: false + name: inverse + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: inverse + is_nullable: false + name: inverse + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: inverse + name: inverse + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_inv + operator_name: linalg_inv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_inv(Tensor A) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_inv_out + operator_name: linalg_inv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_inv.out(Tensor A, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: inverse + operator_name: inverse + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::inverse(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: inverse_out + operator_name: inverse + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::inverse.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: inner + operator_name: inner + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::inner(Tensor self, Tensor other) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: inner_out + operator_name: inner + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::inner.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: outer + operator_name: outer + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::outer(Tensor self, Tensor vec2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: outer_out + operator_name: outer + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::outer.out(Tensor self, Tensor vec2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ger + operator_name: ger + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ger(Tensor self, Tensor vec2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + method_of: + - Type + - Tensor + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: ger_out + operator_name: ger + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ger.out(Tensor self, Tensor vec2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: vec2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_norm + operator_name: linalg_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_norm(Tensor self, Scalar? ord=None, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: ord + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, at::OptionalIntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: ord + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_norm + operator_name: linalg_norm + overload_name: ord_str + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_norm.ord_str(Tensor self, str ord, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view, at::OptionalIntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_norm_out + operator_name: linalg_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_norm.out(Tensor self, Scalar? ord=None, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: ord + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::OptionalIntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: ord + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_norm_out + operator_name: linalg_norm + overload_name: ord_str_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_norm.ord_str_out(Tensor self, str ord, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::string_view, at::OptionalIntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_vector_norm + operator_name: linalg_vector_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_vector_norm(Tensor self, Scalar ord=2, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, at::OptionalIntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_vector_norm_out + operator_name: linalg_vector_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_vector_norm.out(Tensor self, Scalar ord=2, int[1]? dim=None, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::OptionalIntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_matrix_norm + operator_name: linalg_matrix_norm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_norm(Tensor self, Scalar ord, int[] dim=[-2,-1], bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &, at::IntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_norm_out + operator_name: linalg_matrix_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_norm.out(Tensor self, Scalar ord, int[] dim=[-2,-1], bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::IntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_norm + operator_name: linalg_matrix_norm + overload_name: str_ord + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_norm.str_ord(Tensor self, str ord='fro', int[] dim=[-2,-1], bool keepdim=False, *, ScalarType? dtype=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"fro"' + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view, at::IntArrayRef, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"fro"' + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_norm_out + operator_name: linalg_matrix_norm + overload_name: str_ord_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_norm.str_ord_out(Tensor self, str ord='fro', int[] dim=[-2,-1], bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"fro"' + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::string_view, at::IntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '"fro"' + dynamic_type: c10::string_view + is_nullable: false + name: ord + type: c10::string_view + - annotation: null + default: '{-2,-1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _linalg_svd + operator_name: _linalg_svd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_svd(Tensor A, bool full_matrices=False, bool compute_uv=True, *, str? driver=None) -> (Tensor U, Tensor S, Tensor Vh) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor + - dynamic_type: at::Tensor + field_name: S + name: S + type: at::Tensor + - dynamic_type: at::Tensor + field_name: Vh + name: Vh + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_svd_out + operator_name: _linalg_svd + overload_name: U + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_svd.U(Tensor A, bool full_matrices=False, bool compute_uv=True, *, str? driver=None, Tensor(a!) U, Tensor(b!) S, Tensor(c!) Vh) -> (Tensor(a!) U, Tensor(b!) S, Tensor(c!) Vh) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: S + is_nullable: false + name: S + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: Vh + is_nullable: false + name: Vh + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, c10::optional, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: compute_uv + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: S + is_nullable: false + name: S + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: Vh + is_nullable: false + name: Vh + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: S + name: S + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: Vh + name: Vh + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_svd + operator_name: linalg_svd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_svd(Tensor A, bool full_matrices=True, *, str? driver=None) -> (Tensor U, Tensor S, Tensor Vh) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor + - dynamic_type: at::Tensor + field_name: S + name: S + type: at::Tensor + - dynamic_type: at::Tensor + field_name: Vh + name: Vh + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_svd_out + operator_name: linalg_svd + overload_name: U + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_svd.U(Tensor A, bool full_matrices=True, *, str? driver=None, Tensor(a!) U, Tensor(b!) S, Tensor(c!) Vh) -> (Tensor(a!) U, Tensor(b!) S, Tensor(c!) Vh) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: S + is_nullable: false + name: S + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: Vh + is_nullable: false + name: Vh + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, c10::optional, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: full_matrices + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: U + is_nullable: false + name: U + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: S + is_nullable: false + name: S + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: Vh + is_nullable: false + name: Vh + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: U + name: U + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: S + name: S + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: Vh + name: Vh + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_svdvals + operator_name: linalg_svdvals + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_svdvals(Tensor A, *, str? driver=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_svdvals_out + operator_name: linalg_svdvals + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_svdvals.out(Tensor A, *, str? driver=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: driver + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_cond + operator_name: linalg_cond + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cond(Tensor self, Scalar? p=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_cond_out + operator_name: linalg_cond + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cond.out(Tensor self, Scalar? p=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_cond + operator_name: linalg_cond + overload_name: p_str + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cond.p_str(Tensor self, str p) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: p + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: p + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_cond_out + operator_name: linalg_cond + overload_name: p_str_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_cond.p_str_out(Tensor self, str p, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: p + type: c10::string_view + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::string_view, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: p + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_pinv + operator_name: linalg_pinv + overload_name: atol_rtol_tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv.atol_rtol_tensor(Tensor self, *, Tensor? atol=None, Tensor? rtol=None, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_pinv_out + operator_name: linalg_pinv + overload_name: atol_rtol_tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv.atol_rtol_tensor_out(Tensor self, *, Tensor? atol=None, Tensor? rtol=None, bool hermitian=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_pinv + operator_name: linalg_pinv + overload_name: atol_rtol_float + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv.atol_rtol_float(Tensor self, *, float? atol=None, float? rtol=None, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_pinv_out + operator_name: linalg_pinv + overload_name: atol_rtol_float_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv.atol_rtol_float_out(Tensor self, *, float? atol=None, float? rtol=None, bool hermitian=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, c10::optional, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_pinv + operator_name: linalg_pinv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv(Tensor self, float rcond, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: rcond + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: rcond + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_pinv + operator_name: linalg_pinv + overload_name: rcond_tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv.rcond_tensor(Tensor self, Tensor rcond, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rcond + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rcond + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_pinv_out + operator_name: linalg_pinv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv.out(Tensor self, float rcond, bool hermitian=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: rcond + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: rcond + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_pinv_out + operator_name: linalg_pinv + overload_name: out_rcond_tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_pinv.out_rcond_tensor(Tensor self, Tensor rcond, bool hermitian=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rcond + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rcond + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _linalg_solve_ex + operator_name: _linalg_solve_ex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_solve_ex(Tensor A, Tensor B, *, bool left=True, bool check_errors=False) -> (Tensor result, Tensor LU, Tensor pivots, Tensor info) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: result + name: result + type: at::Tensor + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _linalg_solve_ex_out + operator_name: _linalg_solve_ex + overload_name: result + manual_kernel_registration: false + category_override: '' + schema_string: aten::_linalg_solve_ex.result(Tensor A, Tensor B, *, bool left=True, bool check_errors=False, Tensor(a!) result, Tensor(b!) LU, Tensor(c!) pivots, Tensor(d!) info) -> (Tensor(a!) result, Tensor(b!) LU, Tensor(c!) pivots, Tensor(d!) info) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: result + is_nullable: false + name: result + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: result + is_nullable: false + name: result + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: LU + is_nullable: false + name: LU + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + field_name: pivots + is_nullable: false + name: pivots + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: result + name: result + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: LU + name: LU + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: pivots + name: pivots + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_solve_ex + operator_name: linalg_solve_ex + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_solve_ex(Tensor A, Tensor B, *, bool left=True, bool check_errors=False) -> (Tensor result, Tensor info) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: result + name: result + type: at::Tensor + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_solve_ex_out + operator_name: linalg_solve_ex + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_solve_ex.out(Tensor A, Tensor B, *, bool left=True, bool check_errors=False, Tensor(a!) result, Tensor(b!) info) -> (Tensor(a!) result, Tensor(b!) info) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: result + is_nullable: false + name: result + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: check_errors + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: result + is_nullable: false + name: result + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: info + is_nullable: false + name: info + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: result + name: result + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: info + name: info + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_solve + operator_name: linalg_solve + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_solve(Tensor A, Tensor B, *, bool left=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_solve_out + operator_name: linalg_solve + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_solve.out(Tensor A, Tensor B, *, bool left=True, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: B + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: left + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_tensorinv + operator_name: linalg_tensorinv + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_tensorinv(Tensor self, int ind=2) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: ind + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: ind + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_tensorinv_out + operator_name: linalg_tensorinv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_tensorinv.out(Tensor self, int ind=2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: ind + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: ind + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_tensorsolve + operator_name: linalg_tensorsolve + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_tensorsolve(Tensor self, Tensor other, int[]? dims=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dims + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dims + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_tensorsolve_out + operator_name: linalg_tensorsolve + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_tensorsolve.out(Tensor self, Tensor other, int[]? dims=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dims + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::OptionalIntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dims + type: at::OptionalIntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_qr + operator_name: linalg_qr + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_qr(Tensor A, str mode='reduced') -> (Tensor Q, Tensor R) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"reduced"' + dynamic_type: c10::string_view + is_nullable: false + name: mode + type: c10::string_view + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"reduced"' + dynamic_type: c10::string_view + is_nullable: false + name: mode + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: Q + name: Q + type: at::Tensor + - dynamic_type: at::Tensor + field_name: R + name: R + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_qr_out + operator_name: linalg_qr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_qr.out(Tensor A, str mode='reduced', *, Tensor(a!) Q, Tensor(b!) R) -> (Tensor(a!) Q, Tensor(b!) R) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: Q + is_nullable: false + name: Q + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: R + is_nullable: false + name: R + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"reduced"' + dynamic_type: c10::string_view + is_nullable: false + name: mode + type: c10::string_view + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, c10::string_view, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + default: '"reduced"' + dynamic_type: c10::string_view + is_nullable: false + name: mode + type: c10::string_view + - allocate: true + annotation: a! + dynamic_type: at::Tensor + field_name: Q + is_nullable: false + name: Q + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + field_name: R + is_nullable: false + name: R + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + field_name: Q + name: Q + type: at::Tensor & + - dynamic_type: at::Tensor + field_name: R + name: R + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_matrix_power + operator_name: linalg_matrix_power + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_power(Tensor self, int n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_power_out + operator_name: linalg_matrix_power + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_power.out(Tensor self, int n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: n + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank + operator_name: linalg_matrix_rank + overload_name: atol_rtol_tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank.atol_rtol_tensor(Tensor input, *, Tensor? atol=None, Tensor? rtol=None, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::optional &, const c10::optional &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank_out + operator_name: linalg_matrix_rank + overload_name: atol_rtol_tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank.atol_rtol_tensor_out(Tensor input, *, Tensor? atol=None, Tensor? rtol=None, bool hermitian=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: atol + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: rtol + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank + operator_name: linalg_matrix_rank + overload_name: atol_rtol_float + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank.atol_rtol_float(Tensor self, *, float? atol=None, float? rtol=None, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional, c10::optional, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank_out + operator_name: linalg_matrix_rank + overload_name: atol_rtol_float_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank.atol_rtol_float_out(Tensor self, *, float? atol=None, float? rtol=None, bool hermitian=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, c10::optional, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: atol + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: rtol + type: c10::optional + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank + operator_name: linalg_matrix_rank + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank(Tensor self, float tol, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: tol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: tol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank_out + operator_name: linalg_matrix_rank + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank.out(Tensor self, float tol, bool hermitian=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: tol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: tol + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank + operator_name: linalg_matrix_rank + overload_name: tol_tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank.tol_tensor(Tensor input, Tensor tol, bool hermitian=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tol + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tol + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_matrix_rank_out + operator_name: linalg_matrix_rank + overload_name: out_tol_tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_rank.out_tol_tensor(Tensor input, Tensor tol, bool hermitian=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tol + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tol + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: hermitian + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_multi_dot + operator_name: linalg_multi_dot + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_multi_dot(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: linalg_multi_dot_out + operator_name: linalg_multi_dot + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_multi_dot.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: linalg + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: nested_to_padded_tensor + operator_name: nested_to_padded_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::nested_to_padded_tensor(Tensor self, float padding, int[]? output_size=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: padding + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: padding + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nested + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _test_serialization_subcmul + operator_name: _test_serialization_subcmul + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_serialization_subcmul(Tensor self, Tensor other, Scalar alpha=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _test_optional_intlist + operator_name: _test_optional_intlist + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_optional_intlist(Tensor values, int[]? addends) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_optional_filled_intlist + operator_name: _test_optional_filled_intlist + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_optional_filled_intlist(Tensor values, int[2]? addends) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + size: 2 + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + size: 2 + type: at::OptionalIntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_optional_floatlist + operator_name: _test_optional_floatlist + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_optional_floatlist(Tensor values, float[]? addends) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: addends + type: c10::optional> + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional>) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: addends + type: c10::optional> + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_string_default + operator_name: _test_string_default + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_string_default(Tensor dummy, str a="\"'\\", str b='"\'\\') -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dummy + type: const at::Tensor & + - annotation: null + default: '"\"''\\"' + dynamic_type: c10::string_view + is_nullable: false + name: a + type: c10::string_view + - annotation: null + default: '"\"''\\"' + dynamic_type: c10::string_view + is_nullable: false + name: b + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dummy + type: const at::Tensor & + - annotation: null + default: '"\"''\\"' + dynamic_type: c10::string_view + is_nullable: false + name: a + type: c10::string_view + - annotation: null + default: '"\"''\\"' + dynamic_type: c10::string_view + is_nullable: false + name: b + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _test_ambiguous_defaults + operator_name: _test_ambiguous_defaults + overload_name: a + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_ambiguous_defaults.a(Tensor dummy, int a=1, int b=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dummy + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: a + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: b + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dummy + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: a + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: b + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _test_ambiguous_defaults + operator_name: _test_ambiguous_defaults + overload_name: b + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_ambiguous_defaults.b(Tensor dummy, int a=2, str b="2") -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dummy + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: a + type: int64_t + - annotation: null + default: '"2"' + dynamic_type: c10::string_view + is_nullable: false + name: b + type: c10::string_view + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::string_view) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dummy + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: int64_t + is_nullable: false + name: a + type: int64_t + - annotation: null + default: '"2"' + dynamic_type: c10::string_view + is_nullable: false + name: b + type: c10::string_view + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _test_warn_in_autograd + operator_name: _test_warn_in_autograd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_warn_in_autograd(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_autograd_multiple_dispatch + operator_name: _test_autograd_multiple_dispatch + overload_name: fullcoverage + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_autograd_multiple_dispatch.fullcoverage(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_autograd_multiple_dispatch + operator_name: _test_autograd_multiple_dispatch + overload_name: ntonly + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_autograd_multiple_dispatch.ntonly(Tensor self, bool b) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: b + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: b + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _test_autograd_multiple_dispatch_view + operator_name: _test_autograd_multiple_dispatch_view + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_autograd_multiple_dispatch_view(Tensor(a) self) -> Tensor(a) + arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: a + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_autograd_multiple_dispatch_view_copy + operator_name: _test_autograd_multiple_dispatch_view_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_autograd_multiple_dispatch_view_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: segment_reduce + operator_name: segment_reduce + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::segment_reduce(Tensor data, str reduce, *, Tensor? lengths=None, Tensor? indices=None, Tensor? offsets=None, int axis=0, bool unsafe=False, Scalar? initial=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: indices + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unsafe + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::string_view, const c10::optional &, const c10::optional &, const c10::optional &, int64_t, bool, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: indices + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unsafe + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _segment_reduce_backward + operator_name: _segment_reduce_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_segment_reduce_backward(Tensor grad, Tensor output, Tensor data, str reduce, *, Tensor? lengths=None, Tensor? offsets=None, int axis=0, Scalar? initial=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::string_view, const c10::optional &, const c10::optional &, int64_t, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: pad_sequence + operator_name: pad_sequence + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::pad_sequence(Tensor[] sequences, bool batch_first=False, float padding_value=0.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: sequences + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: padding_value + type: double + schema_order_cpp_signature: at::Tensor (at::TensorList, bool, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: sequences + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: padding_value + type: double + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: flatten_dense_tensors + operator_name: flatten_dense_tensors + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::flatten_dense_tensors(Tensor[] tensors) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: unflatten_dense_tensors + operator_name: unflatten_dense_tensors + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unflatten_dense_tensors(Tensor flat, Tensor[] tensors) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: flat + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: flat + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _nested_tensor_from_tensor_list + operator_name: _nested_tensor_from_tensor_list + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_from_tensor_list(Tensor[] list, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: list + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: pin_memory + type: c10::optional + schema_order_cpp_signature: at::Tensor (at::TensorList, c10::optional, c10::optional, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: list + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: pin_memory + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fw_primal_copy + operator_name: _fw_primal_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fw_primal_copy(Tensor self, int level) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_dual_copy + operator_name: _make_dual_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_dual_copy(Tensor primal, Tensor tangent, int level) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: primal + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tangent + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: primal + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tangent + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_as_real_copy + operator_name: view_as_real_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_as_real_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_as_complex_copy + operator_name: view_as_complex_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_as_complex_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _conj_copy + operator_name: _conj_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_conj_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _neg_view_copy + operator_name: _neg_view_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_neg_view_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: as_strided_copy + operator_name: as_strided_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::as_strided_copy(Tensor self, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_broadcast_to_copy + operator_name: _sparse_broadcast_to_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_broadcast_to_copy(Tensor self, int[] size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: diagonal_copy + operator_name: diagonal_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal_copy(Tensor self, int offset=0, int dim1=0, int dim2=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: expand_copy + operator_name: expand_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::expand_copy(Tensor self, SymInt[] size, *, bool implicit=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: implicit + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: implicit + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: permute_copy + operator_name: permute_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::permute_copy(Tensor self, int[] dims) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _reshape_alias_copy + operator_name: _reshape_alias_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_reshape_alias_copy(Tensor self, SymInt[] size, SymInt[] stride) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: select_copy + operator_name: select_copy + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::select_copy.int(Tensor self, int dim, SymInt index) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: detach_copy + operator_name: detach_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::detach_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: slice_copy + operator_name: slice_copy + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::slice_copy.Tensor(Tensor self, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: split_copy + operator_name: split_copy + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::split_copy.Tensor(Tensor self, SymInt split_size, int dim=0) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: split_with_sizes_copy + operator_name: split_with_sizes_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::split_with_sizes_copy(Tensor self, SymInt[] split_sizes, int dim=0) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, at::IntArrayRef, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_copy + operator_name: squeeze_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_copy + operator_name: squeeze_copy + overload_name: dim + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_copy.dim(Tensor self, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_copy + operator_name: squeeze_copy + overload_name: dims + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_copy.dims(Tensor self, int[] dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: t_copy + operator_name: t_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::t_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: transpose_copy + operator_name: transpose_copy + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::transpose_copy.int(Tensor self, int dim0, int dim1) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unsqueeze_copy + operator_name: unsqueeze_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsqueeze_copy(Tensor self, int dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _indices_copy + operator_name: _indices_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_indices_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _values_copy + operator_name: _values_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_values_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: indices_copy + operator_name: indices_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::indices_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: values_copy + operator_name: values_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::values_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: crow_indices_copy + operator_name: crow_indices_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::crow_indices_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: col_indices_copy + operator_name: col_indices_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::col_indices_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: ccol_indices_copy + operator_name: ccol_indices_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::ccol_indices_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: row_indices_copy + operator_name: row_indices_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::row_indices_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unbind_copy + operator_name: unbind_copy + overload_name: int + manual_kernel_registration: false + category_override: '' + schema_string: aten::unbind_copy.int(Tensor self, int dim=0) -> Tensor[] + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::vector (const at::Tensor &, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + name: result + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unbind_copy_out + operator_name: unbind_copy + overload_name: int_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unbind_copy.int_out(Tensor self, int dim=0, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: void (const at::Tensor &, int64_t, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: split_copy_out + operator_name: split_copy + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::split_copy.Tensor_out(Tensor self, SymInt split_size, int dim=0, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: void (const at::Tensor &, int64_t, int64_t, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: split_with_sizes_copy_out + operator_name: split_with_sizes_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::split_with_sizes_copy.out(Tensor self, SymInt[] split_sizes, int dim=0, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: void (const at::Tensor &, at::IntArrayRef, int64_t, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_copy + operator_name: view_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_copy(Tensor self, SymInt[] size) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_copy + operator_name: view_copy + overload_name: dtype + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_copy.dtype(Tensor self, ScalarType dtype) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::ScalarType) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: unfold_copy + operator_name: unfold_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::unfold_copy(Tensor self, int dimension, int size, int step) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: alias_copy + operator_name: alias_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::alias_copy(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_padded_tensor + operator_name: to_padded_tensor + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_padded_tensor(Tensor self, float padding, SymInt[]? output_size=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: padding + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, at::OptionalIntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: padding + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + method_of: + - Type + - Tensor + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_softmax_with_shape + operator_name: _nested_tensor_softmax_with_shape + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_softmax_with_shape(Tensor self, Tensor query) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _transformer_encoder_layer_fwd + operator_name: _transformer_encoder_layer_fwd + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_transformer_encoder_layer_fwd(Tensor src, int embed_dim, int num_heads, Tensor qkv_weight, Tensor qkv_bias, Tensor proj_weight, Tensor proj_bias, bool use_gelu, bool norm_first, float eps, Tensor norm_weight_1, Tensor norm_bias_1, Tensor norm_weight_2, Tensor norm_bias_2, Tensor ffn_weight_1, Tensor ffn_bias_1, Tensor ffn_weight_2, Tensor ffn_bias_2, Tensor? mask=None, int? mask_type=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: use_gelu + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: norm_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, int64_t, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool, double, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: use_gelu + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: norm_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_multi_head_attention + operator_name: _native_multi_head_attention + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_native_multi_head_attention(Tensor query, Tensor key, Tensor value, int embed_dim, int num_head, Tensor qkv_weight, Tensor qkv_bias, Tensor proj_weight, Tensor proj_bias, Tensor? mask=None, bool need_weights=True, bool average_attn_weights=True, int? mask_type=None) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: need_weights + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: average_attn_weights + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: need_weights + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: average_attn_weights + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: scaled_dot_product_attention + operator_name: scaled_dot_product_attention + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::scaled_dot_product_attention(Tensor query, Tensor key, Tensor value, Tensor? attn_mask=None, float dropout_p=0.0, bool is_causal=False, *, float? scale=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: attn_mask + type: const c10::optional & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, double, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: attn_mask + type: const c10::optional & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: nn + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _fused_sdp_choice + operator_name: _fused_sdp_choice + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_sdp_choice(Tensor query, Tensor key, Tensor value, Tensor? attn_mask=None, float dropout_p=0.0, bool is_causal=False, *, float? scale=None) -> int + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: attn_mask + type: const c10::optional & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: int64_t (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, double, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: attn_mask + type: const c10::optional & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: int64_t + name: result + type: int64_t + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _scaled_dot_product_attention_math + operator_name: _scaled_dot_product_attention_math + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_scaled_dot_product_attention_math(Tensor query, Tensor key, Tensor value, Tensor? attn_mask=None, float dropout_p=0.0, bool is_causal=False, Tensor? dropout_mask=None, *, float? scale=None) -> (Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: attn_mask + type: const c10::optional & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: dropout_mask + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, double, bool, const c10::optional &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: attn_mask + type: const c10::optional & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: dropout_mask + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _scaled_dot_product_flash_attention + operator_name: _scaled_dot_product_flash_attention + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_scaled_dot_product_flash_attention(Tensor query, Tensor key, Tensor value, float dropout_p=0.0, bool is_causal=False, bool return_debug_mask=False, *, float? scale=None) -> (Tensor ouput, Tensor logsumexp, Tensor cum_seq_q, Tensor cum_seq_k, int max_q, int max_k, Tensor philox_seed, Tensor philox_offset, Tensor debug_attn_mask) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_debug_mask + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_debug_mask + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: ouput + name: ouput + type: at::Tensor + - dynamic_type: at::Tensor + field_name: logsumexp + name: logsumexp + type: at::Tensor + - dynamic_type: at::Tensor + field_name: cum_seq_q + name: cum_seq_q + type: at::Tensor + - dynamic_type: at::Tensor + field_name: cum_seq_k + name: cum_seq_k + type: at::Tensor + - dynamic_type: int64_t + field_name: max_q + name: max_q + type: int64_t + - dynamic_type: int64_t + field_name: max_k + name: max_k + type: int64_t + - dynamic_type: at::Tensor + field_name: philox_seed + name: philox_seed + type: at::Tensor + - dynamic_type: at::Tensor + field_name: philox_offset + name: philox_offset + type: at::Tensor + - dynamic_type: at::Tensor + field_name: debug_attn_mask + name: debug_attn_mask + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _scaled_dot_product_flash_attention_backward + operator_name: _scaled_dot_product_flash_attention_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_scaled_dot_product_flash_attention_backward(Tensor grad_out, Tensor query, Tensor key, Tensor value, Tensor out, Tensor logsumexp, Tensor cum_seq_q, Tensor cum_seq_k, int max_q, int max_k, float dropout_p, bool is_causal, Tensor philox_seed, Tensor philox_offset, *, float? scale=None) -> (Tensor grad_query, Tensor grad_key, Tensor grad_value) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_k + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_q + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_k + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, double, bool, const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_k + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_q + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_k + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: grad_query + name: grad_query + type: at::Tensor + - dynamic_type: at::Tensor + field_name: grad_key + name: grad_key + type: at::Tensor + - dynamic_type: at::Tensor + field_name: grad_value + name: grad_value + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _scaled_dot_product_efficient_attention + operator_name: _scaled_dot_product_efficient_attention + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_scaled_dot_product_efficient_attention(Tensor query, Tensor key, Tensor value, Tensor? attn_bias, bool compute_log_sumexp, float dropout_p=0.0, bool is_causal=False, *, float? scale=None) -> (Tensor output, Tensor log_sumexp, Tensor philox_seed, Tensor philox_offset) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: attn_bias + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: compute_log_sumexp + type: bool + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, bool, double, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: attn_bias + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: compute_log_sumexp + type: bool + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: log_sumexp + name: log_sumexp + type: at::Tensor + - dynamic_type: at::Tensor + field_name: philox_seed + name: philox_seed + type: at::Tensor + - dynamic_type: at::Tensor + field_name: philox_offset + name: philox_offset + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _scaled_dot_product_efficient_attention_backward + operator_name: _scaled_dot_product_efficient_attention_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_scaled_dot_product_efficient_attention_backward(Tensor grad_out_, Tensor query, Tensor key, Tensor value, Tensor attn_bias, Tensor out, Tensor logsumexp, Tensor philox_seed, Tensor philox_offset, float dropout_p, bool[4] grad_input_mask, bool is_causal=False, *, float? scale=None) -> (Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: attn_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: grad_input_mask + type: ::std::array + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, double, ::std::array, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: attn_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: grad_input_mask + type: ::std::array + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _flash_attention_forward + operator_name: _flash_attention_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_flash_attention_forward(Tensor query, Tensor key, Tensor value, Tensor cum_seq_q, Tensor cum_seq_k, int max_q, int max_k, float dropout_p, bool is_causal, bool return_debug_mask, *, float? scale=None) -> (Tensor output, Tensor softmax_logsumexp, Tensor philox_seed, Tensor philox_offset, Tensor debug_attn_mask) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_k + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_q + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_k + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: return_debug_mask + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, double, bool, bool, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_k + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_q + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_k + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: return_debug_mask + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: softmax_logsumexp + name: softmax_logsumexp + type: at::Tensor + - dynamic_type: at::Tensor + field_name: philox_seed + name: philox_seed + type: at::Tensor + - dynamic_type: at::Tensor + field_name: philox_offset + name: philox_offset + type: at::Tensor + - dynamic_type: at::Tensor + field_name: debug_attn_mask + name: debug_attn_mask + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _flash_attention_backward + operator_name: _flash_attention_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_flash_attention_backward(Tensor grad_out, Tensor query, Tensor key, Tensor value, Tensor out, Tensor logsumexp, Tensor cum_seq_q, Tensor cum_seq_k, int max_q, int max_k, float dropout_p, bool is_causal, Tensor philox_seed, Tensor philox_offset, *, float? scale=None) -> (Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_k + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_q + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_k + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, double, bool, const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cum_seq_k + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_q + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_k + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: is_causal + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _efficient_attention_forward + operator_name: _efficient_attention_forward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_efficient_attention_forward(Tensor query, Tensor key, Tensor value, Tensor? bias, Tensor? cu_seqlens_q, Tensor? cu_seqlens_k, int? max_seqlen_q, float dropout_p, int custom_mask_type, bool compute_log_sumexp=False, *, float? scale=None, Tensor? causal_diagonal=None, Tensor? seqlen_k=None) -> (Tensor output, Tensor logsumexp, Tensor philox_seed, Tensor philox_offset) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_q + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_k + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: max_seqlen_q + type: c10::optional + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: custom_mask_type + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: compute_log_sumexp + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: causal_diagonal + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: seqlen_k + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, c10::optional, double, int64_t, bool, c10::optional, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_q + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_k + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: max_seqlen_q + type: c10::optional + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: custom_mask_type + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: compute_log_sumexp + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: causal_diagonal + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: seqlen_k + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: logsumexp + name: logsumexp + type: at::Tensor + - dynamic_type: at::Tensor + field_name: philox_seed + name: philox_seed + type: at::Tensor + - dynamic_type: at::Tensor + field_name: philox_offset + name: philox_offset + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _efficient_attention_backward + operator_name: _efficient_attention_backward + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_efficient_attention_backward(Tensor grad_out_, Tensor query, Tensor key, Tensor value, Tensor? bias, Tensor out, Tensor? cu_seqlens_q, Tensor? cu_seqlens_k, int max_seqlen_k, int max_seqlen_q, Tensor logsumexp, float dropout_p, Tensor philox_seed, Tensor philox_offset, int custom_mask_type, bool bias_requires_grad, *, float? scale=None, int? num_splits_key=None) -> (Tensor, Tensor, Tensor, Tensor) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_q + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_k + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_seqlen_k + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_seqlen_q + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: custom_mask_type + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_requires_grad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: num_splits_key + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const at::Tensor &, const c10::optional &, const c10::optional &, int64_t, int64_t, const at::Tensor &, double, const at::Tensor &, const at::Tensor &, int64_t, bool, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_q + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cu_seqlens_k + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_seqlen_k + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: max_seqlen_q + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: logsumexp + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_seed + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: philox_offset + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: custom_mask_type + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_requires_grad + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: double + is_nullable: true + kwarg_only: true + name: scale + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: num_splits_key + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + name: result3 + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _triton_scaled_dot_attention + operator_name: _triton_scaled_dot_attention + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_triton_scaled_dot_attention(Tensor q, Tensor k, Tensor v, float dropout_p=0.0) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: k + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: k + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fill_mem_eff_dropout_mask_ + operator_name: _fill_mem_eff_dropout_mask_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fill_mem_eff_dropout_mask_(Tensor(a!) self, float dropout_p, int seed, int offset) -> Tensor(a!) + arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: seed + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + schema_order_cpp_signature: at::Tensor & (at::Tensor &, double, int64_t, int64_t) + schema_order_arguments: + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: self + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: seed + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: self + type: at::Tensor & + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _triton_multi_head_attention + operator_name: _triton_multi_head_attention + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_triton_multi_head_attention(Tensor query, Tensor key, Tensor value, int embed_dim, int num_head, Tensor qkv_weight, Tensor qkv_bias, Tensor proj_weight, Tensor proj_bias, Tensor? mask=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_airy_ai + operator_name: special_airy_ai + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_airy_ai(Tensor x) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_airy_ai_out + operator_name: special_airy_ai + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_airy_ai.out(Tensor x, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_j0 + operator_name: special_bessel_j0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_j0(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_j0_out + operator_name: special_bessel_j0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_j0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_j1 + operator_name: special_bessel_j1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_j1(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_j1_out + operator_name: special_bessel_j1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_j1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_y0 + operator_name: special_bessel_y0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_y0(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_y0_out + operator_name: special_bessel_y0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_y0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_y1 + operator_name: special_bessel_y1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_y1(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_bessel_y1_out + operator_name: special_bessel_y1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_bessel_y1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_t + operator_name: special_chebyshev_polynomial_t + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_t(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_t + operator_name: special_chebyshev_polynomial_t + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_t.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_t + operator_name: special_chebyshev_polynomial_t + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_t.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_t_out + operator_name: special_chebyshev_polynomial_t + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_t.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_t_out + operator_name: special_chebyshev_polynomial_t + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_t.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_t_out + operator_name: special_chebyshev_polynomial_t + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_t.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_u + operator_name: special_chebyshev_polynomial_u + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_u(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_u + operator_name: special_chebyshev_polynomial_u + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_u.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_u + operator_name: special_chebyshev_polynomial_u + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_u.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_u_out + operator_name: special_chebyshev_polynomial_u + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_u.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_u_out + operator_name: special_chebyshev_polynomial_u + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_u.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_u_out + operator_name: special_chebyshev_polynomial_u + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_u.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_v + operator_name: special_chebyshev_polynomial_v + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_v(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_v + operator_name: special_chebyshev_polynomial_v + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_v.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_v + operator_name: special_chebyshev_polynomial_v + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_v.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_v_out + operator_name: special_chebyshev_polynomial_v + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_v.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_v_out + operator_name: special_chebyshev_polynomial_v + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_v.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_v_out + operator_name: special_chebyshev_polynomial_v + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_v.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_w + operator_name: special_chebyshev_polynomial_w + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_w(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_w + operator_name: special_chebyshev_polynomial_w + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_w.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_w + operator_name: special_chebyshev_polynomial_w + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_w.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_w_out + operator_name: special_chebyshev_polynomial_w + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_w.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_chebyshev_polynomial_w_out + operator_name: special_chebyshev_polynomial_w + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_w.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_chebyshev_polynomial_w_out + operator_name: special_chebyshev_polynomial_w + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_chebyshev_polynomial_w.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_hermite_polynomial_h + operator_name: special_hermite_polynomial_h + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_h(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_hermite_polynomial_h + operator_name: special_hermite_polynomial_h + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_h.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_hermite_polynomial_h + operator_name: special_hermite_polynomial_h + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_h.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_hermite_polynomial_h_out + operator_name: special_hermite_polynomial_h + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_h.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_hermite_polynomial_h_out + operator_name: special_hermite_polynomial_h + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_h.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_hermite_polynomial_h_out + operator_name: special_hermite_polynomial_h + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_h.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_hermite_polynomial_he + operator_name: special_hermite_polynomial_he + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_he(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_hermite_polynomial_he + operator_name: special_hermite_polynomial_he + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_he.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_hermite_polynomial_he + operator_name: special_hermite_polynomial_he + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_he.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_hermite_polynomial_he_out + operator_name: special_hermite_polynomial_he + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_he.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_hermite_polynomial_he_out + operator_name: special_hermite_polynomial_he + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_he.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_hermite_polynomial_he_out + operator_name: special_hermite_polynomial_he + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_hermite_polynomial_he.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_laguerre_polynomial_l + operator_name: special_laguerre_polynomial_l + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_laguerre_polynomial_l(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_laguerre_polynomial_l + operator_name: special_laguerre_polynomial_l + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_laguerre_polynomial_l.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_laguerre_polynomial_l + operator_name: special_laguerre_polynomial_l + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_laguerre_polynomial_l.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_laguerre_polynomial_l_out + operator_name: special_laguerre_polynomial_l + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_laguerre_polynomial_l.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_laguerre_polynomial_l_out + operator_name: special_laguerre_polynomial_l + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_laguerre_polynomial_l.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_laguerre_polynomial_l_out + operator_name: special_laguerre_polynomial_l + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_laguerre_polynomial_l.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_legendre_polynomial_p + operator_name: special_legendre_polynomial_p + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_legendre_polynomial_p(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_legendre_polynomial_p + operator_name: special_legendre_polynomial_p + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_legendre_polynomial_p.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_legendre_polynomial_p + operator_name: special_legendre_polynomial_p + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_legendre_polynomial_p.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_legendre_polynomial_p_out + operator_name: special_legendre_polynomial_p + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_legendre_polynomial_p.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_legendre_polynomial_p_out + operator_name: special_legendre_polynomial_p + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_legendre_polynomial_p.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_legendre_polynomial_p_out + operator_name: special_legendre_polynomial_p + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_legendre_polynomial_p.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_i0 + operator_name: special_modified_bessel_i0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_i0(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_i0_out + operator_name: special_modified_bessel_i0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_i0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_i1 + operator_name: special_modified_bessel_i1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_i1(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_i1_out + operator_name: special_modified_bessel_i1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_i1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_k0 + operator_name: special_modified_bessel_k0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_k0(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_k0_out + operator_name: special_modified_bessel_k0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_k0.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_k1 + operator_name: special_modified_bessel_k1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_k1(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_modified_bessel_k1_out + operator_name: special_modified_bessel_k1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_modified_bessel_k1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_scaled_modified_bessel_k0 + operator_name: special_scaled_modified_bessel_k0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_scaled_modified_bessel_k0(Tensor x) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_scaled_modified_bessel_k0_out + operator_name: special_scaled_modified_bessel_k0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_scaled_modified_bessel_k0.out(Tensor x, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_scaled_modified_bessel_k1 + operator_name: special_scaled_modified_bessel_k1 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_scaled_modified_bessel_k1(Tensor x) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_scaled_modified_bessel_k1_out + operator_name: special_scaled_modified_bessel_k1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_scaled_modified_bessel_k1.out(Tensor x, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_t + operator_name: special_shifted_chebyshev_polynomial_t + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_t(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_t + operator_name: special_shifted_chebyshev_polynomial_t + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_t.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_t + operator_name: special_shifted_chebyshev_polynomial_t + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_t.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_t_out + operator_name: special_shifted_chebyshev_polynomial_t + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_t.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_t_out + operator_name: special_shifted_chebyshev_polynomial_t + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_t.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_t_out + operator_name: special_shifted_chebyshev_polynomial_t + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_t.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_u + operator_name: special_shifted_chebyshev_polynomial_u + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_u(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_u + operator_name: special_shifted_chebyshev_polynomial_u + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_u.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_u + operator_name: special_shifted_chebyshev_polynomial_u + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_u.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_u_out + operator_name: special_shifted_chebyshev_polynomial_u + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_u.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_u_out + operator_name: special_shifted_chebyshev_polynomial_u + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_u.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_u_out + operator_name: special_shifted_chebyshev_polynomial_u + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_u.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_v + operator_name: special_shifted_chebyshev_polynomial_v + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_v(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_v + operator_name: special_shifted_chebyshev_polynomial_v + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_v.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_v + operator_name: special_shifted_chebyshev_polynomial_v + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_v.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_v_out + operator_name: special_shifted_chebyshev_polynomial_v + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_v.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_v_out + operator_name: special_shifted_chebyshev_polynomial_v + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_v.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_v_out + operator_name: special_shifted_chebyshev_polynomial_v + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_v.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_w + operator_name: special_shifted_chebyshev_polynomial_w + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_w(Tensor x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_w + operator_name: special_shifted_chebyshev_polynomial_w + overload_name: x_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_w.x_scalar(Scalar x, Tensor n) -> Tensor + arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Scalar &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_w + operator_name: special_shifted_chebyshev_polynomial_w + overload_name: n_scalar + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_w.n_scalar(Tensor x, Scalar n) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Scalar &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_w_out + operator_name: special_shifted_chebyshev_polynomial_w + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_w.out(Tensor x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_shifted_chebyshev_polynomial_w_out + operator_name: special_shifted_chebyshev_polynomial_w + overload_name: x_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_w.x_scalar_out(Scalar x, Tensor n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: x + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: n + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: special_shifted_chebyshev_polynomial_w_out + operator_name: special_shifted_chebyshev_polynomial_w + overload_name: n_scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_shifted_chebyshev_polynomial_w.n_scalar_out(Tensor x, Scalar n, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: n + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_spherical_bessel_j0 + operator_name: special_spherical_bessel_j0 + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_spherical_bessel_j0(Tensor x) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: special_spherical_bessel_j0_out + operator_name: special_spherical_bessel_j0 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::special_spherical_bessel_j0.out(Tensor x, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: special + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foobar + operator_name: _foobar + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foobar(Tensor self, bool arg1=True, bool arg2=True, *, bool arg3=True) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg1 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg2 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: arg3 + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg1 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg2 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: arg3 + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adam_ + operator_name: _fused_adam_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adam_(Tensor(a!)[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, float lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, double, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adam_ + operator_name: _fused_adam_ + overload_name: tensor_lr + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adam_.tensor_lr(Tensor(a!)[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, Tensor lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adamw_ + operator_name: _fused_adamw_ + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adamw_(Tensor(a!)[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, float lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, double, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adamw_ + operator_name: _fused_adamw_ + overload_name: tensor_lr + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adamw_.tensor_lr(Tensor(a!)[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, Tensor lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> () + arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: true + is_factory_method: false + abstract: true + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: false +- name: _propagate_xla_data + operator_name: _propagate_xla_data + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_propagate_xla_data(Tensor input, Tensor output) -> () + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: void (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: false + device_guard: true + with_gil: false + deprecated: false + has_math_kernel: true +- name: _new_zeros_with_same_feature_meta_out + operator_name: _new_zeros_with_same_feature_meta + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_new_zeros_with_same_feature_meta.out(Tensor self, Tensor other, *, int self_num_batch_dims=0, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: self_num_batch_dims + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: self_num_batch_dims + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_ctc_loss_out + operator_name: _cudnn_ctc_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_ctc_loss.out(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank, bool deterministic, bool zero_infinity, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_rnn_flatten_weight_out + operator_name: _cudnn_rnn_flatten_weight + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_rnn_flatten_weight.out(Tensor[] weight_arr, int weight_stride0, SymInt input_size, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, bool bidirectional, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight_arr + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: input_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + schema_order_cpp_signature: at::Tensor & (at::TensorList, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight_arr + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: input_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_rnn_out + operator_name: _cudnn_rnn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_rnn.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor? weight_buf, Tensor hx, Tensor? cx, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight_buf + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, int64_t, const c10::optional &, const at::Tensor &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight_buf + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out4 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_rnn_backward_out + operator_name: _cudnn_rnn_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_rnn_backward.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, int mode, SymInt hidden_size, SymInt proj_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, SymInt[] batch_sizes, Tensor? dropout_state, Tensor reserve, bool[4] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!)[] out3) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: out3 + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: void (const at::Tensor &, at::TensorList, int64_t, const at::Tensor &, const at::Tensor &, const c10::optional &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &, const at::Tensor &, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: proj_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: out3 + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cudnn_init_dropout_state_out + operator_name: _cudnn_init_dropout_state + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cudnn_init_dropout_state.out(float dropout, bool train, int dropout_seed, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dropout_seed + type: int64_t + schema_order_cpp_signature: at::Tensor & (double, bool, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dropout_seed + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_dropout_out + operator_name: _fused_dropout + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_dropout.out(Tensor self, float p, Generator? generator=None, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double, c10::optional, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _masked_scale_out + operator_name: _masked_scale + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_masked_scale.out(Tensor self, Tensor mask, float scale, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_dropout_out + operator_name: native_dropout + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_dropout.out(Tensor input, float p, bool? train, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: true + name: train + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double, c10::optional, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: bool + is_nullable: true + name: train + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_dropout_backward_out + operator_name: native_dropout_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_dropout_backward.out(Tensor grad_output, Tensor mask, float scale, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _conj_physical_out + operator_name: _conj_physical + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_conj_physical.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _add_relu_out + operator_name: _add_relu + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_add_relu.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: add_out + operator_name: add + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::add.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: affine_grid_generator_out + operator_name: affine_grid_generator + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::affine_grid_generator.out(Tensor theta, SymInt[] size, bool align_corners, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_functorch_fallback_out + operator_name: _test_functorch_fallback + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_functorch_fallback.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bartlett_window_out + operator_name: bartlett_window + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bartlett_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bartlett_window_out + operator_name: bartlett_window + overload_name: periodic_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bartlett_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + schema_order_cpp_signature: at::Tensor & (int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantized_batch_norm_out + operator_name: quantized_batch_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_batch_norm.out(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor var, float eps, float output_scale, int output_zero_point, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: output_scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: output_zero_point + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double, double, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: output_scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: output_zero_point + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bernoulli_out + operator_name: bernoulli + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli.Tensor_out(Tensor self, Tensor p, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: p + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: p + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bernoulli + operator_name: bernoulli + overload_name: Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli.Tensor(Tensor self, Tensor p, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: p + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: p + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bernoulli_out + operator_name: bernoulli + overload_name: float_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bernoulli.float_out(Tensor self, float p=0.5, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0.5 + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: binary_cross_entropy_with_logits_out + operator_name: binary_cross_entropy_with_logits + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::binary_cross_entropy_with_logits.out(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: pos_weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: pos_weight + type: const c10::optional & + - annotation: null + default: at::Reduction::Mean + dynamic_type: int64_t + is_nullable: false + name: reduction + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bincount_out + operator_name: bincount + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bincount.out(Tensor self, Tensor? weights=None, int minlength=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weights + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: minlength + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: weights + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: minlength + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: blackman_window_out + operator_name: blackman_window + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: blackman_window_out + operator_name: blackman_window + overload_name: periodic_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + schema_order_cpp_signature: at::Tensor & (int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: block_diag_out + operator_name: block_diag + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::block_diag.out(Tensor[] tensors, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: at::Tensor & (at::TensorList, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: constant_pad_nd_out + operator_name: constant_pad_nd + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::constant_pad_nd.out(Tensor self, SymInt[] pad, Scalar value=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: pad + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: convolution_out + operator_name: convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution.out(Tensor input, Tensor weight, Tensor? bias, int[] stride, SymInt[] padding, int[] dilation, bool transposed, SymInt[] output_padding, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: convolution_backward_out + operator_name: convolution_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution_backward.out(Tensor grad_output, Tensor input, Tensor weight, SymInt[]? bias_sizes, int[] stride, SymInt[] padding, int[] dilation, bool transposed, SymInt[] output_padding, int groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: bias_sizes + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::OptionalIntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: bias_sizes + type: at::OptionalIntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: convolution_overrideable_out + operator_name: convolution_overrideable + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution_overrideable.out(Tensor input, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: convolution_backward_overrideable_out + operator_name: convolution_backward_overrideable + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::convolution_backward_overrideable.out(Tensor grad_output, Tensor input, Tensor weight, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _convolution_out + operator_name: _convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_convolution.out(Tensor input, Tensor weight, Tensor? bias, int[] stride, SymInt[] padding, int[] dilation, bool transposed, SymInt[] output_padding, int groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::IntArrayRef, int64_t, bool, bool, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: transposed + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: cudnn_enabled + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: conv_tbc_out + operator_name: conv_tbc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_tbc.out(Tensor self, Tensor weight, Tensor bias, int pad=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: pad + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bias + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: pad + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: copy_out + operator_name: copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::copy.out(Tensor self, Tensor src, bool non_blocking=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _copy_from_out + operator_name: _copy_from + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_copy_from.out(Tensor self, Tensor dst, bool non_blocking=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _copy_from_and_resize_out + operator_name: _copy_from_and_resize + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_copy_from_and_resize.out(Tensor self, Tensor dst, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dst + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: count_nonzero_out + operator_name: count_nonzero + overload_name: dim_IntList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::count_nonzero.dim_IntList_out(Tensor self, int[] dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: count_nonzero_out + operator_name: count_nonzero + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::count_nonzero.out(Tensor self, int? dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_affine_grid_generator_out + operator_name: cudnn_affine_grid_generator + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_affine_grid_generator.out(Tensor theta, int N, int C, int H, int W, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: theta + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_affine_grid_generator_backward_out + operator_name: cudnn_affine_grid_generator_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_affine_grid_generator_backward.out(Tensor grad, int N, int C, int H, int W, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: H + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: W + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_batch_norm_out + operator_name: cudnn_batch_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_batch_norm.out(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_batch_norm_backward_out + operator_name: cudnn_batch_norm_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_batch_norm_backward.out(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, float epsilon, Tensor reserveSpace, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserveSpace + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, double, const at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserveSpace + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution_out + operator_name: cudnn_convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution.out(Tensor self, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution_transpose_out + operator_name: cudnn_convolution_transpose + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution_transpose.out(Tensor self, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: allow_tf32 + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mps_convolution_transpose_out + operator_name: _mps_convolution_transpose + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mps_convolution_transpose.out(Tensor self, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mps_convolution_transpose_backward_out + operator_name: mps_convolution_transpose_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mps_convolution_transpose_backward.out(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] output_padding, int[] stride, int[] dilation, int groups, bool[2] output_mask, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, ::std::array, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution_relu_out + operator_name: cudnn_convolution_relu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution_relu.out(Tensor self, Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_convolution_add_relu_out + operator_name: cudnn_convolution_add_relu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_convolution_add_relu.out(Tensor self, Tensor weight, Tensor z, Scalar? alpha, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: alpha + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: alpha + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_grid_sampler_out + operator_name: cudnn_grid_sampler + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_grid_sampler.out(Tensor self, Tensor grid, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cudnn_grid_sampler_backward_out + operator_name: cudnn_grid_sampler_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cudnn_grid_sampler_backward.out(Tensor self, Tensor grid, Tensor grad_output, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _ctc_loss_out + operator_name: _ctc_loss + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_ctc_loss.out(Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, int blank=0, bool zero_infinity=False, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _ctc_loss_out + operator_name: _ctc_loss + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_ctc_loss.Tensor_out(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, int blank=0, bool zero_infinity=False, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_lengths + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: target_lengths + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _ctc_loss_backward_out + operator_name: _ctc_loss_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_ctc_loss_backward.out(Tensor grad, Tensor log_probs, Tensor targets, int[] input_lengths, int[] target_lengths, Tensor neg_log_likelihood, Tensor log_alpha, int blank, bool zero_infinity=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: neg_log_likelihood + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_alpha + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, const at::Tensor &, const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_probs + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: targets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: target_lengths + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: neg_log_likelihood + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: log_alpha + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: blank + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: zero_infinity + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: diag_embed_out + operator_name: diag_embed + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::diag_embed.out(Tensor self, int offset=0, int dim1=-2, int dim2=-1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: -2 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: -2 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: diagonal_backward_out + operator_name: diagonal_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal_backward.out(Tensor grad_output, SymInt[] input_sizes, int offset, int dim1, int dim2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_out + operator_name: div + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: div_out + operator_name: div + overload_name: Scalar_mode_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::div.Scalar_mode_out(Tensor self, Scalar other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + dynamic_type: c10::string_view + is_nullable: true + kwarg_only: true + name: rounding_mode + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: embedding_out + operator_name: embedding + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding.out(Tensor weight, Tensor indices, SymInt padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: embedding_dense_backward_out + operator_name: embedding_dense_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_dense_backward.out(Tensor grad_output, Tensor indices, SymInt num_weights, SymInt padding_idx, bool scale_grad_by_freq, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: embedding_renorm_out + operator_name: embedding_renorm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_renorm.out(Tensor self, Tensor indices, float max_norm, float norm_type, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: max_norm + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: norm_type + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, double, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: max_norm + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: norm_type + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: embedding_renorm + operator_name: embedding_renorm + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::embedding_renorm(Tensor self, Tensor indices, float max_norm, float norm_type) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: max_norm + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: norm_type + type: double + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: max_norm + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: norm_type + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _embedding_bag_forward_only_out + operator_name: _embedding_bag_forward_only + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_forward_only.out(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(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, int64_t, bool, const c10::optional &, bool, int64_t, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _embedding_bag_out + operator_name: _embedding_bag + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag.out(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(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, int64_t, bool, const c10::optional &, bool, int64_t, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: sparse + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: include_last_offset + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _embedding_bag_dense_backward_out + operator_name: _embedding_bag_dense_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_dense_backward.out(Tensor grad, Tensor indices, Tensor offset2bag, Tensor bag_size, Tensor maximum_indices, SymInt num_weights, bool scale_grad_by_freq, int mode, Tensor? per_sample_weights, int padding_idx=-1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: maximum_indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, bool, int64_t, const c10::optional &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: bag_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: maximum_indices + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_weights + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: scale_grad_by_freq + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: per_sample_weights + type: const c10::optional & + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _embedding_bag_per_sample_weights_backward_out + operator_name: _embedding_bag_per_sample_weights_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_embedding_bag_per_sample_weights_backward.out(Tensor grad, Tensor weight, Tensor indices, Tensor offsets, Tensor offset2bag, int mode, int padding_idx=-1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offset2bag + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + name: padding_idx + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_out + operator_name: empty + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty.names_out(int[] size, *, Dimname[]? names, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_permuted_out + operator_name: empty_permuted + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty_permuted.out(SymInt[] size, int[] physical_layout, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: physical_layout + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: physical_layout + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_empty_out + operator_name: new_empty + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_empty.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_empty_strided_out + operator_name: new_empty_strided + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_empty_strided.out(Tensor self, SymInt[] size, SymInt[] stride, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_full_out + operator_name: new_full + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_full.out(Tensor self, SymInt[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_zeros_out + operator_name: new_zeros + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_zeros.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: new_ones_out + operator_name: new_ones + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::new_ones.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _empty_affine_quantized_out + operator_name: _empty_affine_quantized + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_empty_affine_quantized.out(SymInt[] size, *, float scale=1, int zero_point=0, MemoryFormat? memory_format=contiguous_format, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + kwarg_only: true + name: scale + type: double + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: zero_point + type: int64_t + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, double, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + kwarg_only: true + name: scale + type: double + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: zero_point + type: int64_t + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _empty_per_channel_affine_quantized_out + operator_name: _empty_per_channel_affine_quantized + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_empty_per_channel_affine_quantized.out(SymInt[] size, *, Tensor scales, Tensor zero_points, int axis, MemoryFormat? memory_format=contiguous_format, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, const at::Tensor &, const at::Tensor &, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: MemoryFormat::Contiguous + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize_out + operator_name: resize + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize.out(Tensor self, SymInt[] size, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize + operator_name: resize + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize(Tensor self, SymInt[] size, *, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _resize_output_out + operator_name: _resize_output + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_resize_output.out(Tensor self, SymInt[] size, Device device, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Device, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _resize_output + operator_name: _resize_output + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_resize_output(Tensor self, SymInt[] size, Device device) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, at::Device) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Device + is_nullable: false + name: device + type: at::Device + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_quantized_out + operator_name: empty_quantized + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty_quantized.out(int[] size, Tensor qtensor, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qtensor + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qtensor + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_like_out + operator_name: empty_like + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty_like.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: empty_strided_out + operator_name: empty_strided + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::empty_strided.out(SymInt[] size, SymInt[] stride, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: fill_out + operator_name: fill + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fill.Scalar_out(Tensor self, Scalar value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: fill_out + operator_name: fill + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fill.Tensor_out(Tensor self, Tensor value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: full_out + operator_name: full + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::full.names_out(int[] size, Scalar fill_value, *, Dimname[]? names, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, const at::Scalar &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: full_like_out + operator_name: full_like + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::full_like.out(Tensor self, Scalar fill_value, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: fill_value + type: const at::Scalar & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: from_file_out + operator_name: from_file + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::from_file.out(str filename, bool? shared=None, int? size=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: filename + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: shared + type: c10::optional + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: true + name: size + type: c10::optional + schema_order_cpp_signature: at::Tensor & (c10::string_view, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: filename + type: c10::string_view + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: shared + type: c10::optional + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: true + name: size + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: grid_sampler_2d_out + operator_name: grid_sampler_2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_2d.out(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: grid_sampler_2d_backward_out + operator_name: grid_sampler_2d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_2d_backward.out(Tensor grad_output, Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, bool[2] output_mask, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, ::std::array, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _grid_sampler_2d_cpu_fallback_out + operator_name: _grid_sampler_2d_cpu_fallback + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_grid_sampler_2d_cpu_fallback.out(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: grid_sampler_3d_out + operator_name: grid_sampler_3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_3d.out(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: grid_sampler_3d_backward_out + operator_name: grid_sampler_3d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::grid_sampler_3d_backward.out(Tensor grad_output, Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, bool[2] output_mask, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, bool, ::std::array, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grid + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: interpolation_mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: padding_mode + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: align_corners + type: bool + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hann_window_out + operator_name: hann_window + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hann_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hann_window_out + operator_name: hann_window + overload_name: periodic_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hann_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + schema_order_cpp_signature: at::Tensor & (int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window_out + operator_name: hamming_window + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window_out + operator_name: hamming_window + overload_name: periodic_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + schema_order_cpp_signature: at::Tensor & (int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window_out + operator_name: hamming_window + overload_name: periodic_alpha_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window.periodic_alpha_out(int window_length, bool periodic, float alpha, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + schema_order_cpp_signature: at::Tensor & (int64_t, bool, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hamming_window_out + operator_name: hamming_window + overload_name: periodic_alpha_beta_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hamming_window.periodic_alpha_beta_out(int window_length, bool periodic, float alpha, float beta, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + schema_order_cpp_signature: at::Tensor & (int64_t, bool, double, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: alpha + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: kaiser_window_out + operator_name: kaiser_window + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::kaiser_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: kaiser_window_out + operator_name: kaiser_window + overload_name: periodic_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::kaiser_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + schema_order_cpp_signature: at::Tensor & (int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: kaiser_window_out + operator_name: kaiser_window + overload_name: beta_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::kaiser_window.beta_out(int window_length, bool periodic, float beta, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + schema_order_cpp_signature: at::Tensor & (int64_t, bool, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: window_length + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: periodic + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: beta + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_group_norm_out + operator_name: native_group_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_group_norm.out(Tensor input, Tensor? weight, Tensor? bias, SymInt N, SymInt C, SymInt HxW, int group, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_group_norm_backward_out + operator_name: native_group_norm_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_group_norm_backward.out(Tensor grad_out, Tensor input, Tensor mean, Tensor rstd, Tensor? weight, SymInt N, SymInt C, SymInt HxW, int group, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, int64_t, int64_t, int64_t, int64_t, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: N + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: C + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: HxW + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: group + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_put_out + operator_name: index_put + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_put.out(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::List> &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _index_put_impl_out + operator_name: _index_put_impl + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_index_put_impl.out(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False, bool unsafe=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unsafe + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::List> &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unsafe + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _index_put_impl + operator_name: _index_put_impl + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_index_put_impl(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False, bool unsafe=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unsafe + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const c10::List> &, const at::Tensor &, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const c10::List> & + is_nullable: true + name: indices + type: const c10::List> & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: unsafe + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: isnan_out + operator_name: isnan + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::isnan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_layer_norm_out + operator_name: native_layer_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_layer_norm.out(Tensor input, SymInt[] normalized_shape, Tensor? weight, Tensor? bias, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::IntArrayRef, const c10::optional &, const c10::optional &, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_layer_norm_backward_out + operator_name: native_layer_norm_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_layer_norm_backward.out(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: normalized_shape + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: rstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: linear_backward_out + operator_name: linear_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linear_backward.out(Tensor self, Tensor grad_output, Tensor weight, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear_out + operator_name: mkldnn_linear + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear.out(Tensor self, Tensor weight, Tensor? bias=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear_backward_input_out + operator_name: mkldnn_linear_backward_input + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear_backward_input.out(int[] input_size, Tensor grad_output, Tensor weight, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear_backward_weights_out + operator_name: mkldnn_linear_backward_weights + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear_backward_weights.out(Tensor grad_output, Tensor input, Tensor weight, bool bias_defined, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_defined + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_defined + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_linear_backward_out + operator_name: mkldnn_linear_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_linear_backward.out(Tensor self, Tensor grad_output, Tensor weight, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: matmul_backward_out + operator_name: matmul_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::matmul_backward.out(Tensor grad, Tensor self, Tensor other, bool[2] mask, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, ::std::array, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _aminmax_out + operator_name: _aminmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_aminmax.out(Tensor self, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _aminmax_out + operator_name: _aminmax + overload_name: dim_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_aminmax.dim_out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: max_pool2d_backward_out + operator_name: max_pool2d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::max_pool2d_backward.out(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool2d_out + operator_name: mkldnn_max_pool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool2d.out(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool2d_backward_out + operator_name: mkldnn_max_pool2d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool2d_backward.out(Tensor grad_output, Tensor output, Tensor input, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool3d_out + operator_name: mkldnn_max_pool3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool3d.out(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_max_pool3d_backward_out + operator_name: mkldnn_max_pool3d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_max_pool3d_backward.out(Tensor grad_output, Tensor output, Tensor input, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantized_max_pool1d_out + operator_name: quantized_max_pool1d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_max_pool1d.out(Tensor self, int[1] kernel_size, int[1] stride=[], int[1] padding=0, int[1] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 1 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 1 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantized_max_pool2d_out + operator_name: quantized_max_pool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_max_pool2d.out(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantized_max_pool3d_out + operator_name: quantized_max_pool3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantized_max_pool3d.out(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: ceil_mode + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: median_out + operator_name: median + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::median.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: nanmedian_out + operator_name: nanmedian + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::nanmedian.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mps_convolution_out + operator_name: _mps_convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mps_convolution.out(Tensor self, Tensor weight, Tensor? bias, int[] padding, int[] stride, int[] dilation, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mps_convolution_backward_out + operator_name: mps_convolution_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_convolution_out + operator_name: mkldnn_convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_convolution.out(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, int[] stride, int[] dilation, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_rnn_layer_out + operator_name: mkldnn_rnn_layer + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_rnn_layer.out(Tensor input, Tensor weight0, Tensor weight1, Tensor weight2, Tensor weight3, Tensor hx_, Tensor cx_, bool reverse, int[] batch_sizes, int mode, int hidden_size, int num_layers, bool has_biases, bool bidirectional, bool batch_first, bool train, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight0 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_ + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, at::IntArrayRef, int64_t, int64_t, int64_t, bool, bool, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight0 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_ + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_rnn_layer_backward_out + operator_name: mkldnn_rnn_layer_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_rnn_layer_backward.out(Tensor input, Tensor weight1, Tensor weight2, Tensor weight3, Tensor weight4, Tensor hx_, Tensor cx_tmp, Tensor output, Tensor hy_, Tensor cy_, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, bool reverse, int mode, int hidden_size, int num_layers, bool has_biases, bool train, bool bidirectional, int[] batch_sizes, bool batch_first, Tensor workspace, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4, Tensor(f!) out5, Tensor(g!) out6) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!), Tensor(f!), Tensor(g!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: out5 + output: true + type: at::Tensor & + - allocate: true + annotation: g! + dynamic_type: at::Tensor + is_nullable: false + name: out6 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight4 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_tmp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, int64_t, int64_t, int64_t, bool, bool, bool, at::IntArrayRef, bool, const at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight4 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx_tmp + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy_ + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: reverse + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: out5 + output: true + type: at::Tensor & + - allocate: true + annotation: g! + dynamic_type: at::Tensor + is_nullable: false + name: out6 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out4 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out5 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out6 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_batch_norm_out + operator_name: miopen_batch_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_batch_norm.out(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: exponential_average_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_batch_norm_backward_out + operator_name: miopen_batch_norm_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_batch_norm_backward.out(Tensor input, Tensor grad_output, Tensor weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_var, float epsilon, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: epsilon + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_convolution_out + operator_name: miopen_convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_convolution.out(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_convolution_transpose_out + operator_name: miopen_convolution_transpose + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_convolution_transpose.out(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, SymInt[] output_padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_depthwise_convolution_out + operator_name: miopen_depthwise_convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_depthwise_convolution.out(Tensor self, Tensor weight, Tensor? bias, SymInt[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: benchmark + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: deterministic + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_rnn_out + operator_name: miopen_rnn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_rnn.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor hx, Tensor? cx, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, int64_t, const at::Tensor &, const c10::optional &, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out4 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: miopen_rnn_backward_out + operator_name: miopen_rnn_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::miopen_rnn_backward.out(Tensor input, Tensor[] weight, int weight_stride0, Tensor weight_buf, Tensor hx, Tensor? cx, Tensor output, Tensor? grad_output, Tensor? grad_hy, Tensor? grad_cy, int mode, int hidden_size, int num_layers, bool batch_first, float dropout, bool train, bool bidirectional, int[] batch_sizes, Tensor? dropout_state, Tensor reserve, bool[4] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!)[] out3) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: out3 + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: void (const at::Tensor &, at::TensorList, int64_t, const at::Tensor &, const at::Tensor &, const c10::optional &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, int64_t, int64_t, int64_t, bool, double, bool, bool, at::IntArrayRef, const c10::optional &, const at::Tensor &, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weight + type: at::TensorList + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: weight_stride0 + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight_buf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: cx + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_output + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: mode + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: hidden_size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: batch_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: dropout_state + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: reserve + type: const at::Tensor & + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: out3 + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_sparse_matmul_out + operator_name: _sparse_sparse_matmul + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sparse_matmul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mul_out + operator_name: mul + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mul.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_batch_norm_legit_functional + operator_name: _native_batch_norm_legit_functional + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_native_batch_norm_legit_functional(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor, Tensor running_mean_out, Tensor running_var_out) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, bool, double, double) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + name: result1 + type: at::Tensor + - dynamic_type: at::Tensor + name: result2 + type: at::Tensor + - dynamic_type: at::Tensor + field_name: running_mean_out + name: running_mean_out + type: at::Tensor + - dynamic_type: at::Tensor + field_name: running_var_out + name: running_var_out + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_batch_norm_legit_no_training_out + operator_name: _native_batch_norm_legit_no_training + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_native_batch_norm_legit_no_training.out(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, float momentum, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, double, double, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_var + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_stats_out + operator_name: batch_norm_stats + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_stats.out(Tensor input, float eps, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_gather_stats_out + operator_name: batch_norm_gather_stats + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_gather_stats.out(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, int count, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: count + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, double, double, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: count + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_gather_stats_with_counts_out + operator_name: batch_norm_gather_stats_with_counts + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_gather_stats_with_counts.out(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, Tensor counts, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: counts + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, double, double, const at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: counts + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_batch_norm_backward_out + operator_name: native_batch_norm_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_batch_norm_backward.out(Tensor grad_out, Tensor input, Tensor? weight, Tensor? running_mean, Tensor? running_var, Tensor? save_mean, Tensor? save_invstd, bool train, float eps, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_invstd + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: save_invstd + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_backward_reduce_out + operator_name: batch_norm_backward_reduce + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_backward_reduce.out(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, Tensor? weight, bool input_g, bool weight_g, bool bias_g, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: input_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: weight_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_g + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, bool, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: bool + is_nullable: false + name: input_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: weight_g + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bias_g + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_backward_elemt_out + operator_name: batch_norm_backward_elemt + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_backward_elemt.out(Tensor grad_out, Tensor input, Tensor mean, Tensor invstd, Tensor? weight, Tensor sum_dy, Tensor sum_dy_xmu, Tensor count, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy_xmu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_out + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mean + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: invstd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: weight + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: sum_dy_xmu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: batch_norm_update_stats_out + operator_name: batch_norm_update_stats + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::batch_norm_update_stats.out(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const c10::optional &, const c10::optional &, double, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_mean + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: running_var + type: const c10::optional & + - annotation: null + dynamic_type: double + is_nullable: false + name: momentum + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nnpack_spatial_convolution_out + operator_name: _nnpack_spatial_convolution + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nnpack_spatial_convolution.out(Tensor input, Tensor weight, Tensor? bias, SymInt[2] padding, int[2] stride=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: ones_out + operator_name: ones + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ones.names_out(int[] size, *, Dimname[]? names, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: ones_like_out + operator_name: ones_like + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ones_like.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _euclidean_dist_out + operator_name: _euclidean_dist + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_euclidean_dist.out(Tensor x1, Tensor x2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cdist_forward_out + operator_name: _cdist_forward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cdist_forward.out(Tensor x1, Tensor x2, float p, int? compute_mode, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: compute_mode + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: compute_mode + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cdist_backward_out + operator_name: _cdist_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cdist_backward.out(Tensor grad, Tensor x1, Tensor x2, float p, Tensor cdist, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cdist + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x2 + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cdist + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _pdist_forward_out + operator_name: _pdist_forward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pdist_forward.out(Tensor self, float p=2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: p + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _pdist_backward_out + operator_name: _pdist_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pdist_backward.out(Tensor grad, Tensor self, float p, Tensor pdist, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pdist + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, double, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: pdist + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: pixel_shuffle_out + operator_name: pixel_shuffle + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::pixel_shuffle.out(Tensor self, int upscale_factor, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: upscale_factor + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: upscale_factor + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: pixel_unshuffle_out + operator_name: pixel_unshuffle + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::pixel_unshuffle.out(Tensor self, int downscale_factor, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: downscale_factor + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: downscale_factor + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: channel_shuffle_out + operator_name: channel_shuffle + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::channel_shuffle.out(Tensor self, int groups, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _pin_memory_out + operator_name: _pin_memory + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pin_memory.out(Tensor self, Device? device=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: scalar_tensor_out + operator_name: scalar_tensor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::scalar_tensor.out(Scalar s, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: s + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: s + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand_out + operator_name: rand + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand.names_out(SymInt[] size, *, Dimname[]? names, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand_out + operator_name: rand + overload_name: generator_with_names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand.generator_with_names_out(SymInt[] size, *, Generator? generator, Dimname[]? names, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rand_like_out + operator_name: rand_like + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rand_like.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_like_out + operator_name: randint_like + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint_like.out(Tensor self, SymInt high, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: randint_like_out + operator_name: randint_like + overload_name: low_dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randint_like.low_dtype_out(Tensor self, SymInt low, SymInt high, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: low + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: high + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn_out + operator_name: randn + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn.names_out(SymInt[] size, *, Dimname[]? names, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn_out + operator_name: randn + overload_name: generator_with_names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn.generator_with_names_out(SymInt[] size, *, Generator? generator, Dimname[]? names, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: randn_like_out + operator_name: randn_like + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::randn_like.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: repeat_out + operator_name: repeat + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::repeat.out(Tensor self, SymInt[] repeats, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: repeats + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: repeats + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: repeat_interleave_out + operator_name: repeat_interleave + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::repeat_interleave.Tensor_out(Tensor repeats, *, int? output_size=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: repeats + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: repeats + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: output_size + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mkldnn_reshape_out + operator_name: _mkldnn_reshape + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mkldnn_reshape.out(Tensor self, int[] shape, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: relu_out + operator_name: relu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::relu.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: select_backward_out + operator_name: select_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::select_backward.out(Tensor grad_output, SymInt[] input_sizes, int dim, SymInt index, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: celu_out + operator_name: celu + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::celu.out(Tensor self, Scalar alpha=1.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1.0 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: slice_backward_out + operator_name: slice_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slice_backward.out(Tensor grad_output, SymInt[] input_sizes, int dim, SymInt start, SymInt end, SymInt step, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: end + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: start + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: end + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: slice_scatter_out + operator_name: slice_scatter + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slice_scatter.out(Tensor self, Tensor src, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, c10::optional, c10::optional, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: select_scatter_out + operator_name: select_scatter + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::select_scatter.out(Tensor self, Tensor src, int dim, SymInt index, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: diagonal_scatter_out + operator_name: diagonal_scatter + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal_scatter.out(Tensor self, Tensor src, int offset=0, int dim1=0, int dim2=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: as_strided_scatter_out + operator_name: as_strided_scatter + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::as_strided_scatter.out(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unsafe_split_out + operator_name: unsafe_split + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsafe_split.Tensor_out(Tensor self, SymInt split_size, int dim=0, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: void (const at::Tensor &, int64_t, int64_t, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: split_size + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unsafe_split_with_sizes_out + operator_name: unsafe_split_with_sizes + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsafe_split_with_sizes.out(Tensor self, SymInt[] split_sizes, int dim=0, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: void (const at::Tensor &, at::IntArrayRef, int64_t, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: split_sizes + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sum_out + operator_name: sum + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sum.out(Tensor self, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: std_mean_out + operator_name: std_mean + overload_name: correction_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::std_mean.correction_out(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: prod_out + operator_name: prod + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::prod.out(Tensor self, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _mkldnn_transpose_out + operator_name: _mkldnn_transpose + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_mkldnn_transpose.out(Tensor self, int dim0, int dim1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: flip_out + operator_name: flip + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::flip.out(Tensor self, int[] dims, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: roll_out + operator_name: roll + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::roll.out(Tensor self, SymInt[1] shifts, int[1] dims=[], *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shifts + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + size: 1 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shifts + size: 1 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + size: 1 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rot90_out + operator_name: rot90 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rot90.out(Tensor self, int k=1, int[] dims=[0,1], *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: '{0,1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: k + type: int64_t + - annotation: null + default: '{0,1}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _transform_bias_rescale_qkv_out + operator_name: _transform_bias_rescale_qkv + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_transform_bias_rescale_qkv.out(Tensor qkv, Tensor qkv_bias, int num_heads, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_from_mask_out + operator_name: _nested_tensor_from_mask + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_from_mask.out(Tensor t, Tensor mask, bool mask_check=True, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: t + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: mask_check + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: t + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: mask_check + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_from_padded_out + operator_name: _nested_from_padded + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_from_padded.out(Tensor padded, Tensor cpu_nested_shape_example, bool fuse_transform_0213=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cpu_nested_shape_example + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: fuse_transform_0213 + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cpu_nested_shape_example + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: fuse_transform_0213 + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_size_out + operator_name: _nested_tensor_size + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_size.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_strides_out + operator_name: _nested_tensor_strides + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_strides.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_storage_offsets_out + operator_name: _nested_tensor_storage_offsets + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_storage_offsets.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_from_padded_and_nested_example_out + operator_name: _nested_from_padded_and_nested_example + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_from_padded_and_nested_example.out(Tensor padded, Tensor nt_example, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nt_example + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: padded + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nt_example + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_view_from_buffer_copy_out + operator_name: _nested_view_from_buffer_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_view_from_buffer_copy.out(Tensor self, Tensor nested_size, Tensor nested_strides, Tensor offsets, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_strides + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_size + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: nested_strides + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _trilinear_out + operator_name: _trilinear + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_trilinear.out(Tensor i1, Tensor i2, Tensor i3, int[] expand1, int[] expand2, int[] expand3, int[] sumdim, int unroll_dim=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sumdim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: unroll_dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: i3 + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand1 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: expand3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: sumdim + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: unroll_dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unique_out + operator_name: _unique + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unique.out(Tensor self, bool sorted=True, bool return_inverse=False, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unique_dim_out + operator_name: unique_dim + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unique_dim.out(Tensor self, int dim, bool sorted=True, bool return_inverse=False, bool return_counts=False, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unique_consecutive_out + operator_name: unique_consecutive + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unique_consecutive.out(Tensor self, bool return_inverse=False, bool return_counts=False, int? dim=None, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, c10::optional, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unique_dim_consecutive_out + operator_name: unique_dim_consecutive + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unique_dim_consecutive.out(Tensor self, int dim, bool return_inverse=False, bool return_counts=False, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, int64_t, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unique2_out + operator_name: _unique2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unique2.out(Tensor self, bool sorted=True, bool return_inverse=False, bool return_counts=False, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, bool, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: sorted + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_inverse + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: return_counts + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _unsafe_view_out + operator_name: _unsafe_view + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_unsafe_view.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: var_mean_out + operator_name: var_mean + overload_name: correction_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::var_mean.correction_out(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::OptionalIntArrayRef, const c10::optional &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: dim + size: 1 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: correction + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: keepdim + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _weight_norm_interface_out + operator_name: _weight_norm_interface + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_weight_norm_interface.out(Tensor v, Tensor g, int dim=0, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: g + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: g + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _weight_norm_interface_backward_out + operator_name: _weight_norm_interface_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_weight_norm_interface_backward.out(Tensor grad_w, Tensor saved_v, Tensor saved_g, Tensor saved_norms, int dim, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_w + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_g + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_norms + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_w + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_v + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_g + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: saved_norms + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: zeros_out + operator_name: zeros + overload_name: names_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::zeros.names_out(int[] size, *, Dimname[]? names, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::DimnameList + is_nullable: true + kwarg_only: true + name: names + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _efficientzerotensor_out + operator_name: _efficientzerotensor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_efficientzerotensor.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: zeros_like_out + operator_name: zeros_like + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::zeros_like.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _standard_gamma_grad_out + operator_name: _standard_gamma_grad + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_standard_gamma_grad.out(Tensor self, Tensor output, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _standard_gamma_out + operator_name: _standard_gamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_standard_gamma.out(Tensor self, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _dirichlet_grad_out + operator_name: _dirichlet_grad + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_dirichlet_grad.out(Tensor x, Tensor alpha, Tensor total, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: alpha + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: alpha + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: total + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sample_dirichlet_out + operator_name: _sample_dirichlet + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sample_dirichlet.out(Tensor self, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: poisson_out + operator_name: poisson + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::poisson.out(Tensor self, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: binomial_out + operator_name: binomial + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::binomial.out(Tensor count, Tensor prob, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: prob + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: count + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: prob + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_norm_out + operator_name: native_norm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_norm.out(Tensor self, Scalar p=2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: native_norm_out + operator_name: native_norm + overload_name: ScalarOpt_dim_dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::native_norm.ScalarOpt_dim_dtype_out(Tensor self, Scalar? p, int[1] dim, bool keepdim, ScalarType? dtype, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::IntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_sum_out + operator_name: _sparse_sum + overload_name: dim_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sum.dim_out(Tensor self, int[1] dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_sum_backward_out + operator_name: _sparse_sum_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_sum_backward.out(Tensor grad, Tensor self, int[] dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_csr_sum_out + operator_name: _sparse_csr_sum + overload_name: dim_dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_csr_sum.dim_dtype_out(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_csr_prod_out + operator_name: _sparse_csr_prod + overload_name: dim_dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_csr_prod.dim_dtype_out(Tensor self, int[1] dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + size: 1 + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: keepdim + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + kwarg_only: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_softmax_out + operator_name: _sparse_softmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_softmax_backward_data_out + operator_name: _sparse_softmax_backward_data + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_softmax_backward_data.out(Tensor grad_output, Tensor output, int dim, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_log_softmax_out + operator_name: _sparse_log_softmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_log_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: bool + is_nullable: false + name: half_to_float + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_log_softmax_backward_data_out + operator_name: _sparse_log_softmax_backward_data + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_log_softmax_backward_data.out(Tensor grad_output, Tensor output, int dim, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _spdiags_out + operator_name: _spdiags + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_spdiags.out(Tensor diagonals, Tensor offsets, int[] shape, Layout? layout=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: diagonals + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: diagonals + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: offsets + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: shape + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm_out + operator_name: norm + overload_name: ScalarOpt_dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.ScalarOpt_dtype_out(Tensor self, Scalar? p, *, ScalarType dtype, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const c10::optional &, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: true + name: p + type: const c10::optional & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + kwarg_only: true + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: norm_out + operator_name: norm + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::norm.Scalar_out(Tensor self, Scalar p=2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: clone_out + operator_name: clone + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::clone.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize_as_out + operator_name: resize_as + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize_as.out(Tensor self, Tensor the_template, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize_as + operator_name: resize_as + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize_as(Tensor self, Tensor the_template, *, MemoryFormat? memory_format=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize_as_sparse_out + operator_name: resize_as_sparse + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize_as_sparse.out(Tensor self, Tensor the_template, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: resize_as_sparse + operator_name: resize_as_sparse + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::resize_as_sparse(Tensor self, Tensor the_template) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: the_template + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: zero_out + operator_name: zero + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::zero.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: zero + operator_name: zero + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::zero(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sub_out + operator_name: sub + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sub.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rsub_out + operator_name: rsub + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rsub.Tensor_out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rsub_out + operator_name: rsub + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rsub.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_addmm_out + operator_name: _sparse_addmm + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_addmm.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mat2 + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: beta + type: const at::Scalar & + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_coo_tensor_out + operator_name: sparse_coo_tensor + overload_name: size_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_coo_tensor.size_out(int[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_coo_tensor_with_dims_out + operator_name: _sparse_coo_tensor_with_dims + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_coo_tensor_with_dims.out(int sparse_dim, int dense_dim, int[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (int64_t, int64_t, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_coo_tensor_with_dims_and_tensors_out + operator_name: _sparse_coo_tensor_with_dims_and_tensors + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_coo_tensor_with_dims_and_tensors.out(int sparse_dim, int dense_dim, SymInt[] size, Tensor indices, Tensor values, *, bool? is_coalesced=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + schema_order_cpp_signature: at::Tensor & (int64_t, int64_t, at::IntArrayRef, const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: indices + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + kwarg_only: true + name: is_coalesced + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_resize_out + operator_name: sparse_resize + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_resize.out(Tensor self, int[] size, int sparse_dim, int dense_dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_resize + operator_name: sparse_resize + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_resize(Tensor self, int[] size, int sparse_dim, int dense_dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_resize_and_clear_out + operator_name: sparse_resize_and_clear + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_resize_and_clear.out(Tensor self, int[] size, int sparse_dim, int dense_dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + schema_order_cpp_signature: const at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: const at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_resize_and_clear + operator_name: sparse_resize_and_clear + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_resize_and_clear(Tensor self, int[] size, int sparse_dim, int dense_dim) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dense_dim + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: sparse_mask_out + operator_name: sparse_mask + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::sparse_mask.out(Tensor self, Tensor mask, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_mask_projection_out + operator_name: _sparse_mask_projection + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_mask_projection.out(Tensor self, Tensor mask, bool accumulate_matches=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate_matches + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate_matches + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_dense_out + operator_name: _to_dense + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_dense.out(Tensor self, ScalarType? dtype=None, bool? masked_grad=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: masked_grad + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: masked_grad + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _coalesce_out + operator_name: _coalesce + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_coalesce.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _coalesced_out + operator_name: _coalesced + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_coalesced.out(Tensor self, bool coalesced, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: coalesced + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: coalesced + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _coalesced + operator_name: _coalesced + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_coalesced(Tensor self, bool coalesced) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: coalesced + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: coalesced + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: copy_sparse_to_sparse_out + operator_name: copy_sparse_to_sparse + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::copy_sparse_to_sparse.out(Tensor self, Tensor src, bool non_blocking=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: copy_sparse_to_sparse + operator_name: copy_sparse_to_sparse + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::copy_sparse_to_sparse(Tensor self, Tensor src, bool non_blocking=False) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_sparse_out + operator_name: _to_sparse + overload_name: sparse_dim_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse.sparse_dim_out(Tensor self, int sparse_dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: sparse_dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_sparse_out + operator_name: _to_sparse + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse.out(Tensor self, *, Layout? layout=None, int[2]? blocksize=None, int? dense_dim=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: blocksize + size: 2 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::OptionalIntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + kwarg_only: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + kwarg_only: true + name: blocksize + size: 2 + type: at::OptionalIntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + kwarg_only: true + name: dense_dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_sparse_csr_out + operator_name: _to_sparse_csr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_csr.out(Tensor self, int? dense_dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_sparse_csc_out + operator_name: _to_sparse_csc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_csc.out(Tensor self, int? dense_dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_sparse_bsr_out + operator_name: _to_sparse_bsr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_bsr.out(Tensor self, int[2] blocksize, int? dense_dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_sparse_bsc_out + operator_name: _to_sparse_bsc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_sparse_bsc.out(Tensor self, int[2] blocksize, int? dense_dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: blocksize + size: 2 + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dense_dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_mkldnn_out + operator_name: to_mkldnn + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_mkldnn.out(Tensor self, ScalarType? dtype=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_reorder_conv2d_weight_out + operator_name: mkldnn_reorder_conv2d_weight + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_reorder_conv2d_weight.out(Tensor self, int[2] padding=0, int[2] stride=1, int[2] dilation=1, int groups=1, int[]? input_size=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: input_size + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::OptionalIntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: input_size + type: at::OptionalIntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_reorder_conv3d_weight_out + operator_name: mkldnn_reorder_conv3d_weight + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_reorder_conv3d_weight.out(Tensor self, int[3] padding=0, int[3] stride=1, int[3] dilation=1, int groups=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: groups + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_tensor_dynamic_out + operator_name: quantize_per_tensor_dynamic + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor_dynamic.out(Tensor self, ScalarType dtype, bool reduce_range, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + dynamic_type: bool + is_nullable: false + name: reduce_range + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::ScalarType, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - annotation: null + dynamic_type: bool + is_nullable: false + name: reduce_range + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_tensor_out + operator_name: quantize_per_tensor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor.out(Tensor self, float scale, int zero_point, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, int64_t, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_tensor_out + operator_name: quantize_per_tensor + overload_name: tensor_qparams_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor.tensor_qparams_out(Tensor self, Tensor scale, Tensor zero_point, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_tensor_out + operator_name: quantize_per_tensor + overload_name: tensors_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_tensor.tensors_out(Tensor[] tensors, Tensor scales, Tensor zero_points, ScalarType dtype, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: void (at::TensorList, const at::Tensor &, const at::Tensor &, at::ScalarType, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: quantize_per_channel_out + operator_name: quantize_per_channel + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::quantize_per_channel.out(Tensor self, Tensor scales, Tensor zero_points, int axis, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scales + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_points + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: dequantize_out + operator_name: dequantize + overload_name: self_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::dequantize.self_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: dequantize_out + operator_name: dequantize + overload_name: tensors_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::dequantize.tensors_out(Tensor[] tensors, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: q_per_channel_scales_out + operator_name: q_per_channel_scales + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::q_per_channel_scales.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: q_per_channel_zero_points_out + operator_name: q_per_channel_zero_points + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::q_per_channel_zero_points.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: int_repr_out + operator_name: int_repr + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::int_repr.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_per_tensor_quantized_tensor_out + operator_name: _make_per_tensor_quantized_tensor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_per_tensor_quantized_tensor.out(Tensor self, float scale, int zero_point, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_per_channel_quantized_tensor_out + operator_name: _make_per_channel_quantized_tensor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_per_channel_quantized_tensor.out(Tensor self, Tensor scale, Tensor zero_point, int axis, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: fake_quantize_per_tensor_affine_cachemask_out + operator_name: fake_quantize_per_tensor_affine_cachemask + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_tensor_affine_cachemask.out(Tensor self, float scale, int zero_point, int quant_min, int quant_max, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, double, int64_t, int64_t, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: zero_point + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out + operator_name: _fake_quantize_per_tensor_affine_cachemask_tensor_qparams + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams.out(Tensor self, Tensor scale, Tensor zero_point, Tensor fake_quant_enabled, int quant_min, int quant_max, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_enabled + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_enabled + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fake_quantize_learnable_per_tensor_affine_out + operator_name: _fake_quantize_learnable_per_tensor_affine + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_learnable_per_tensor_affine.out(Tensor self, Tensor scale, Tensor zero_point, int quant_min, int quant_max, float grad_factor=1.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: fake_quantize_per_channel_affine_cachemask_out + operator_name: fake_quantize_per_channel_affine_cachemask + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::fake_quantize_per_channel_affine_cachemask.out(Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fake_quantize_learnable_per_channel_affine_out + operator_name: _fake_quantize_learnable_per_channel_affine + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fake_quantize_learnable_per_channel_affine.out(Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max, float grad_factor=1.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, int64_t, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: axis + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + default: 1.0 + dynamic_type: double + is_nullable: false + name: grad_factor + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_moving_avg_obs_fq_helper_out + operator_name: _fused_moving_avg_obs_fq_helper + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_moving_avg_obs_fq_helper.out(Tensor self, Tensor observer_on, Tensor fake_quant_on, Tensor(a!) running_min, Tensor(b!) running_max, Tensor(c!) scale, Tensor(d!) zero_point, float averaging_const, int quant_min, int quant_max, int ch_axis, bool per_row_fake_quant=False, bool symmetric_quant=False, *, Tensor(e!) out0, Tensor(f!) out1) -> (Tensor(e!), Tensor(f!)) + arguments: + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: at::Tensor & + - annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: at::Tensor & + - annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, double, int64_t, int64_t, int64_t, bool, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: at::Tensor & + - annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: at::Tensor & + - annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_moving_avg_obs_fq_helper_functional + operator_name: _fused_moving_avg_obs_fq_helper_functional + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_moving_avg_obs_fq_helper_functional(Tensor self, Tensor observer_on, Tensor fake_quant_on, Tensor running_min, Tensor running_max, Tensor scale, Tensor zero_point, float averaging_const, int quant_min, int quant_max, int ch_axis, bool per_row_fake_quant=False, bool symmetric_quant=False) -> (Tensor output, Tensor mask, Tensor running_min_out, Tensor running_max_out, Tensor scale_out, Tensor zero_point_out) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, double, int64_t, int64_t, int64_t, bool, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: observer_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: fake_quant_on + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_min + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: running_max + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scale + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: zero_point + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: averaging_const + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_min + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: quant_max + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: ch_axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: per_row_fake_quant + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: symmetric_quant + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + field_name: output + name: output + type: at::Tensor + - dynamic_type: at::Tensor + field_name: mask + name: mask + type: at::Tensor + - dynamic_type: at::Tensor + field_name: running_min_out + name: running_min_out + type: at::Tensor + - dynamic_type: at::Tensor + field_name: running_max_out + name: running_max_out + type: at::Tensor + - dynamic_type: at::Tensor + field_name: scale_out + name: scale_out + type: at::Tensor + - dynamic_type: at::Tensor + field_name: zero_point_out + name: zero_point_out + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _to_copy_out + operator_name: _to_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_to_copy.out(Tensor self, *, bool non_blocking=False, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: non_blocking + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: non_blocking + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: at::MemoryFormat + is_nullable: true + kwarg_only: true + name: memory_format + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _lstm_mps_out + operator_name: _lstm_mps + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_lstm_mps.out(Tensor input, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4, Tensor(f!) out5) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!), Tensor(f!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: out5 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, at::TensorList, at::TensorList, bool, int64_t, double, bool, bool, bool, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + - allocate: true + annotation: f! + dynamic_type: at::Tensor + is_nullable: false + name: out5 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out4 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out5 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: lstm_mps_backward_out + operator_name: lstm_mps_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lstm_mps_backward.out(Tensor? grad_y, Tensor? grad_hy, Tensor? grad_cy, Tensor z_state, Tensor cell_state_fwd, Tensor input, Tensor layersOutputs, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first, *, Tensor(a!) out0, Tensor(b!)[] out1, Tensor(c!)[] out2) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: out1 + output: true + type: at::TensorList + - allocate: true + annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: out2 + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_y + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z_state + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cell_state_fwd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: layersOutputs + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: void (const c10::optional &, const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, at::TensorList, at::TensorList, bool, int64_t, double, bool, bool, bool, at::Tensor &, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_y + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: z_state + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cell_state_fwd + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: layersOutputs + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: hx + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: params + type: at::TensorList + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_biases + type: bool + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_layers + type: int64_t + - annotation: null + dynamic_type: double + is_nullable: false + name: dropout + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + name: train + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: bidirectional + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: out1 + output: true + type: at::TensorList + - allocate: true + annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: out2 + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_lstm_cell_out + operator_name: _thnn_fused_lstm_cell + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_lstm_cell.out(Tensor input_gates, Tensor hidden_gates, Tensor cx, Tensor? input_bias=None, Tensor? hidden_bias=None, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_lstm_cell_backward_impl_out + operator_name: _thnn_fused_lstm_cell_backward_impl + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_lstm_cell_backward_impl.out(Tensor? grad_hy, Tensor? grad_cy, Tensor cx, Tensor cy, Tensor workspace, bool has_bias, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + schema_order_cpp_signature: ::std::tuple (const c10::optional &, const c10::optional &, const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_hy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: grad_cy + type: const c10::optional & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cx + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: cy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_gru_cell_out + operator_name: _thnn_fused_gru_cell + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_gru_cell.out(Tensor input_gates, Tensor hidden_gates, Tensor hx, Tensor? input_bias=None, Tensor? hidden_bias=None, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hidden_gates + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: hx + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: input_bias + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: hidden_bias + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _thnn_fused_gru_cell_backward_out + operator_name: _thnn_fused_gru_cell_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_thnn_fused_gru_cell_backward.out(Tensor grad_hy, Tensor workspace, bool has_bias, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3, Tensor(e!) out4) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!), Tensor(e!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_hy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_hy + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: workspace + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: has_bias + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - allocate: true + annotation: d! + dynamic_type: at::Tensor + is_nullable: false + name: out3 + output: true + type: at::Tensor & + - allocate: true + annotation: e! + dynamic_type: at::Tensor + is_nullable: false + name: out4 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out3 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out4 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _pack_padded_sequence_out + operator_name: _pack_padded_sequence + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_pack_padded_sequence.out(Tensor input, Tensor lengths, bool batch_first, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: lengths + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, bool, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: input + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: lengths + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: batch_first + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set_out + operator_name: set + overload_name: source_Storage_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::set.source_Storage_out(Tensor self, Storage source, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Storage, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set + operator_name: set + overload_name: source_Storage + manual_kernel_registration: false + category_override: '' + schema_string: aten::set.source_Storage(Tensor self, Storage source) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Storage) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set_out + operator_name: set + overload_name: source_Storage_storage_offset_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::set.source_Storage_storage_offset_out(Tensor self, Storage source, SymInt storage_offset, SymInt[] size, SymInt[] stride=[], *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Storage, int64_t, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set + operator_name: set + overload_name: source_Storage_storage_offset + manual_kernel_registration: false + category_override: '' + schema_string: aten::set.source_Storage_storage_offset(Tensor self, Storage source, SymInt storage_offset, SymInt[] size, SymInt[] stride=[]) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor (const at::Tensor &, at::Storage, int64_t, at::IntArrayRef, at::IntArrayRef) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Storage + is_nullable: false + name: source + type: at::Storage + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: storage_offset + type: int64_t + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set_out + operator_name: set + overload_name: source_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::set.source_Tensor_out(Tensor self, Tensor source, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set + operator_name: set + overload_name: source_Tensor + manual_kernel_registration: false + category_override: '' + schema_string: aten::set.source_Tensor(Tensor self, Tensor source) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set_out + operator_name: set + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::set.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: set + operator_name: set + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::set(Tensor self) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor (const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: lift_out + operator_name: lift + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lift.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: lift_fresh_copy_out + operator_name: lift_fresh_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::lift_fresh_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_fill_out + operator_name: masked_fill + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_fill.Scalar_out(Tensor self, Tensor mask, Scalar value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_fill_out + operator_name: masked_fill + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_fill.Tensor_out(Tensor self, Tensor mask, Tensor value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: masked_scatter_out + operator_name: masked_scatter + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::masked_scatter.out(Tensor self, Tensor mask, Tensor source, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _masked_softmax_out + operator_name: _masked_softmax + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_masked_softmax.out(Tensor self, Tensor mask, int? dim=None, int? mask_type=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _masked_softmax_backward_out + operator_name: _masked_softmax_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_masked_softmax_backward.out(Tensor grad_output, Tensor output, Tensor mask, int? dim=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: mask + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: dim + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: put_out + operator_name: put + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::put.out(Tensor self, Tensor index, Tensor source, bool accumulate=False, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: source + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: accumulate + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_fill_out + operator_name: index_fill + overload_name: int_Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill.int_Scalar_out(Tensor self, int dim, Tensor index, Scalar value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: index_fill_out + operator_name: index_fill + overload_name: int_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::index_fill.int_Tensor_out(Tensor self, int dim, Tensor index, Tensor value, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: index + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_and_out + operator_name: bitwise_and + overload_name: Scalar_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_and.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_or_out + operator_name: bitwise_or + overload_name: Scalar_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_or.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_xor_out + operator_name: bitwise_xor + overload_name: Scalar_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_xor.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: __lshift___out + operator_name: __lshift__ + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::__lshift__.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: __lshift___out + operator_name: __lshift__ + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::__lshift__.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_left_shift_out + operator_name: bitwise_left_shift + overload_name: Scalar_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_left_shift.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: __rshift___out + operator_name: __rshift__ + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::__rshift__.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: other + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: __rshift___out + operator_name: __rshift__ + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::__rshift__.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bitwise_right_shift_out + operator_name: bitwise_right_shift + overload_name: Scalar_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bitwise_right_shift.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: random_out + operator_name: random + overload_name: from_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::random.from_out(Tensor self, int from, int? to, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: from + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: to + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: from + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: to + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: random + operator_name: random + overload_name: from + manual_kernel_registration: false + category_override: '' + schema_string: aten::random.from(Tensor self, int from, int? to, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: from + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: to + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: from + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: true + name: to + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: random_out + operator_name: random + overload_name: to_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::random.to_out(Tensor self, int to, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: to + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: to + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: random + operator_name: random + overload_name: to + manual_kernel_registration: false + category_override: '' + schema_string: aten::random.to(Tensor self, int to, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: to + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, int64_t, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: to + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: random_out + operator_name: random + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::random.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: random + operator_name: random + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::random(Tensor self, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: uniform_out + operator_name: uniform + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::uniform.out(Tensor self, float from=0, float to=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: from + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: to + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: from + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: to + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: uniform + operator_name: uniform + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::uniform(Tensor self, float from=0, float to=1, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: from + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: to + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: from + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: to + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cauchy_out + operator_name: cauchy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::cauchy.out(Tensor self, float median=0, float sigma=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: median + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: sigma + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: median + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: sigma + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: cauchy + operator_name: cauchy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::cauchy(Tensor self, float median=0, float sigma=1, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: median + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: sigma + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: median + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: sigma + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_normal_out + operator_name: log_normal + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_normal.out(Tensor self, float mean=1, float std=2, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: log_normal + operator_name: log_normal + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::log_normal(Tensor self, float mean=1, float std=2, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 2 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: exponential_out + operator_name: exponential + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::exponential.out(Tensor self, float lambd=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: lambd + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: lambd + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: exponential + operator_name: exponential + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::exponential(Tensor self, float lambd=1, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: lambd + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: lambd + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: geometric_out + operator_name: geometric + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::geometric.out(Tensor self, float p, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: geometric + operator_name: geometric + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::geometric(Tensor self, float p, *, Generator? generator=None) -> Tensor + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor (const at::Tensor &, double, c10::optional) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: p + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: tril_indices_out + operator_name: tril_indices + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::tril_indices.out(int row, int col, int offset=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: triu_indices_out + operator_name: triu_indices + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::triu_indices.out(int row, int col, int offset=0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + schema_order_cpp_signature: at::Tensor & (int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: row + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: col + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: trace_out + operator_name: trace + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::trace.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _cholesky_solve_helper_out + operator_name: _cholesky_solve_helper + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_cholesky_solve_helper.out(Tensor self, Tensor A, bool upper, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: upper + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: A + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: upper + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: dist_out + operator_name: dist + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::dist.out(Tensor self, Tensor other, Scalar p=2, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Scalar &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: p + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _histogramdd_bin_edges_out + operator_name: _histogramdd_bin_edges + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_histogramdd_bin_edges.out(Tensor self, int[] bins, *, float[]? range=None, Tensor? weight=None, bool density=False, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: void (const at::Tensor &, at::IntArrayRef, c10::optional>, const c10::optional &, bool, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _histogramdd_from_bin_cts_out + operator_name: _histogramdd_from_bin_cts + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_histogramdd_from_bin_cts.out(Tensor self, int[] bins, *, float[]? range=None, Tensor? weight=None, bool density=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, c10::optional>, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: bins + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: at::ArrayRef + is_nullable: true + kwarg_only: true + name: range + type: c10::optional> + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _histogramdd_from_bin_tensors_out + operator_name: _histogramdd_from_bin_tensors + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_histogramdd_from_bin_tensors.out(Tensor self, Tensor[] bins, *, Tensor? weight=None, bool density=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: bins + type: at::TensorList + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::TensorList, const c10::optional &, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: bins + type: at::TensorList + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: weight + type: const c10::optional & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: density + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: remainder_out + operator_name: remainder + overload_name: Scalar_Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::remainder.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: argsort_out + operator_name: argsort + overload_name: stable_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::argsort.stable_out(Tensor self, *, bool stable, int dim=-1, bool descending=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: stable + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, int64_t, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: stable + type: bool + - annotation: null + default: -1 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: dim + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: descending + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unfold_backward_out + operator_name: unfold_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unfold_backward.out(Tensor grad_in, SymInt[] input_sizes, int dim, int size, int step, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_in + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_in + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: input_sizes + type: at::IntArrayRef + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: normal_out + operator_name: normal + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::normal.out(Tensor self, float mean=0, float std=1, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, double, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: double + is_nullable: false + name: mean + type: double + - annotation: null + default: 1 + dynamic_type: double + is_nullable: false + name: std + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::Generator + is_nullable: true + kwarg_only: true + name: generator + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _amp_foreach_non_finite_check_and_unscale_out + operator_name: _amp_foreach_non_finite_check_and_unscale + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_amp_foreach_non_finite_check_and_unscale.out(Tensor[] self, Tensor(b!) found_inf, Tensor inv_scale, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: inv_scale + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, at::Tensor &, const at::Tensor &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: inv_scale + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _amp_foreach_non_finite_check_and_unscale + operator_name: _amp_foreach_non_finite_check_and_unscale + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_amp_foreach_non_finite_check_and_unscale(Tensor[] self, Tensor found_inf, Tensor inv_scale) -> (Tensor[] self_out, Tensor found_inf_out) + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: inv_scale + type: const at::Tensor & + schema_order_cpp_signature: ::std::tuple<::std::vector,at::Tensor> (at::TensorList, const at::Tensor &, const at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: inv_scale + type: const at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + field_name: self_out + name: self_out + type: ::std::vector + - dynamic_type: at::Tensor + field_name: found_inf_out + name: found_inf_out + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _amp_update_scale_out + operator_name: _amp_update_scale + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_amp_update_scale.out(Tensor self, Tensor(b!) growth_tracker, Tensor found_inf, float scale_growth_factor, float scale_backoff_factor, int growth_interval, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: growth_tracker + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_growth_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_backoff_factor + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: growth_interval + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &, const at::Tensor &, double, double, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: growth_tracker + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_growth_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_backoff_factor + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: growth_interval + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _amp_update_scale + operator_name: _amp_update_scale + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_amp_update_scale(Tensor self, Tensor growth_tracker, Tensor found_inf, float scale_growth_factor, float scale_backoff_factor, int growth_interval) -> (Tensor, Tensor growth_tracker_out) + arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: growth_tracker + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_growth_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_backoff_factor + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: growth_interval + type: int64_t + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, double, int64_t) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: growth_tracker + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: found_inf + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_growth_factor + type: double + - annotation: null + dynamic_type: double + is_nullable: false + name: scale_backoff_factor + type: double + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: growth_interval + type: int64_t + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: result0 + type: at::Tensor + - dynamic_type: at::Tensor + field_name: growth_tracker_out + name: growth_tracker_out + type: at::Tensor + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add_out + operator_name: _foreach_add + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add_out + operator_name: _foreach_add + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add.List_out(Tensor[] self, Tensor[] other, *, Scalar alpha=1, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_add_out + operator_name: _foreach_add + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_add.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub_out + operator_name: _foreach_sub + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub_out + operator_name: _foreach_sub + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub.List_out(Tensor[] self, Tensor[] other, *, Scalar alpha=1, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + kwarg_only: true + name: alpha + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sub_out + operator_name: _foreach_sub + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sub.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_out + operator_name: _foreach_mul + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_out + operator_name: _foreach_mul + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_out + operator_name: _foreach_mul + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_mul_out + operator_name: _foreach_mul + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_mul.Tensor_out(Tensor[] self, Tensor other, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, const at::Tensor &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: other + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div_out + operator_name: _foreach_div + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div_out + operator_name: _foreach_div + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_div_out + operator_name: _foreach_div + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_div.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max_out + operator_name: _foreach_clamp_max + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max_out + operator_name: _foreach_clamp_max + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_max_out + operator_name: _foreach_clamp_max + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_max.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min_out + operator_name: _foreach_clamp_min + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min_out + operator_name: _foreach_clamp_min + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_clamp_min_out + operator_name: _foreach_clamp_min + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_clamp_min.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum_out + operator_name: _foreach_maximum + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum_out + operator_name: _foreach_maximum + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_maximum_out + operator_name: _foreach_maximum + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_maximum.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum_out + operator_name: _foreach_minimum + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: scalar + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum_out + operator_name: _foreach_minimum + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: other + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_minimum_out + operator_name: _foreach_minimum + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_minimum.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv_out + operator_name: _foreach_addcdiv + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv.Scalar_out(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar value=1, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv_out + operator_name: _foreach_addcdiv + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv.ScalarList_out(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcdiv_out + operator_name: _foreach_addcdiv + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcdiv.Tensor_out(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Tensor scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul_out + operator_name: _foreach_addcmul + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul.Scalar_out(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar value=1, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + default: 1 + dynamic_type: const at::Scalar & + is_nullable: false + name: value + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul_out + operator_name: _foreach_addcmul + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul.ScalarList_out(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Scalar[] scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: scalars + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_addcmul_out + operator_name: _foreach_addcmul + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_addcmul.Tensor_out(Tensor[] self, Tensor[] tensor1, Tensor[] tensor2, Tensor scalars, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensor2 + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: scalars + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_abs_out + operator_name: _foreach_abs + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_abs.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_acos_out + operator_name: _foreach_acos + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_acos.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_asin_out + operator_name: _foreach_asin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_asin.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_atan_out + operator_name: _foreach_atan + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_atan.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_ceil_out + operator_name: _foreach_ceil + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_ceil.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_cos_out + operator_name: _foreach_cos + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_cos.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_cosh_out + operator_name: _foreach_cosh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_cosh.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_erf_out + operator_name: _foreach_erf + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_erf.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_erfc_out + operator_name: _foreach_erfc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_erfc.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_exp_out + operator_name: _foreach_exp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_exp.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_expm1_out + operator_name: _foreach_expm1 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_expm1.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_floor_out + operator_name: _foreach_floor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_floor.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_frac_out + operator_name: _foreach_frac + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_frac.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lerp_out + operator_name: _foreach_lerp + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lerp.List_out(Tensor[] self, Tensor[] tensors1, Tensor[] weights, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weights + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: weights + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lerp_out + operator_name: _foreach_lerp + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lerp.Scalar_out(Tensor[] self, Tensor[] tensors1, Scalar weight, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: tensors1 + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: weight + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_lgamma_out + operator_name: _foreach_lgamma + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_lgamma.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log_out + operator_name: _foreach_log + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log10_out + operator_name: _foreach_log10 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log10.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log1p_out + operator_name: _foreach_log1p + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log1p.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_log2_out + operator_name: _foreach_log2 + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_log2.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_neg_out + operator_name: _foreach_neg + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_neg.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_norm_out + operator_name: _foreach_norm + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_norm.Scalar_out(Tensor[] self, Scalar ord=2, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + default: 2 + dynamic_type: const at::Scalar & + is_nullable: false + name: ord + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow_out + operator_name: _foreach_pow + overload_name: List_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow.List_out(Tensor[] self, Tensor[] exponent, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exponent + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow_out + operator_name: _foreach_pow + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow.Scalar_out(Tensor[] self, Scalar exponent, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + schema_order_cpp_signature: void (at::TensorList, const at::Scalar &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: exponent + type: const at::Scalar & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_pow_out + operator_name: _foreach_pow + overload_name: ScalarList_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_pow.ScalarList_out(Tensor[] self, Scalar[] exponent, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: exponent + type: at::ArrayRef + schema_order_cpp_signature: void (at::TensorList, at::ArrayRef, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: false + name: exponent + type: at::ArrayRef + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_reciprocal_out + operator_name: _foreach_reciprocal + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_reciprocal.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_round_out + operator_name: _foreach_round + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_round.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sigmoid_out + operator_name: _foreach_sigmoid + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sigmoid.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sign_out + operator_name: _foreach_sign + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sign.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sin_out + operator_name: _foreach_sin + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sin.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sinh_out + operator_name: _foreach_sinh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sinh.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_sqrt_out + operator_name: _foreach_sqrt + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_sqrt.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_tan_out + operator_name: _foreach_tan + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_tan.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_tanh_out + operator_name: _foreach_tanh + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_tanh.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_trunc_out + operator_name: _foreach_trunc + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_trunc.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_zero_out + operator_name: _foreach_zero + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_zero.out(Tensor[] self, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: void (at::TensorList, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_zero + operator_name: _foreach_zero + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_zero(Tensor[] self) -> Tensor[] self_out + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + schema_order_cpp_signature: ::std::vector (at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + field_name: self_out + name: self_out + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_copy_out + operator_name: _foreach_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_copy.out(Tensor[] self, Tensor[] src, bool non_blocking=False, *, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: src + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: void (at::TensorList, at::TensorList, bool, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: src + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foreach_copy + operator_name: _foreach_copy + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foreach_copy(Tensor[] self, Tensor[] src, bool non_blocking=False) -> Tensor[] self_out + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: src + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + schema_order_cpp_signature: ::std::vector (at::TensorList, at::TensorList, bool) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: src + type: at::TensorList + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + name: non_blocking + type: bool + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + field_name: self_out + name: self_out + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: bucketize_out + operator_name: bucketize + overload_name: Scalar_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::bucketize.Scalar_out(Scalar self, Tensor boundaries, *, bool out_int32=False, bool right=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Scalar &, const at::Tensor &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: self + type: const at::Scalar & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: boundaries + type: const at::Tensor & + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: out_int32 + type: bool + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: right + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu_jvp_out + operator_name: glu_jvp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu_jvp.out(Tensor glu, Tensor x, Tensor dx, int dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: glu_backward_jvp_out + operator_name: glu_backward_jvp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::glu_backward_jvp.out(Tensor grad_x, Tensor grad_glu, Tensor x, Tensor dgrad_glu, Tensor dx, int dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dgrad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: x + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dgrad_glu + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: dx + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: hardswish_backward_out + operator_name: hardswish_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::hardswish_backward.out(Tensor grad_output, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: rrelu_with_noise_backward_out + operator_name: rrelu_with_noise_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::rrelu_with_noise_backward.out(Tensor grad_output, Tensor self, Tensor noise, Scalar lower, Scalar upper, bool training, bool self_is_result, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: noise + type: const at::Tensor & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: lower + type: const at::Scalar & + - annotation: null + dynamic_type: const at::Scalar & + is_nullable: false + name: upper + type: const at::Scalar & + - annotation: null + dynamic_type: bool + is_nullable: false + name: training + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: self_is_result + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: mkldnn_adaptive_avg_pool2d_backward_out + operator_name: mkldnn_adaptive_avg_pool2d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::mkldnn_adaptive_avg_pool2d_backward.out(Tensor grad_output, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _adaptive_avg_pool2d_out + operator_name: _adaptive_avg_pool2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _adaptive_avg_pool2d_backward_out + operator_name: _adaptive_avg_pool2d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool2d_backward.out(Tensor grad_output, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _adaptive_avg_pool3d_out + operator_name: _adaptive_avg_pool3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool3d.out(Tensor self, SymInt[3] output_size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: output_size + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _adaptive_avg_pool3d_backward_out + operator_name: _adaptive_avg_pool3d_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_adaptive_avg_pool3d_backward.out(Tensor grad_output, Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _slow_conv2d_backward_out + operator_name: _slow_conv2d_backward + overload_name: output_mask_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_slow_conv2d_backward.output_mask_out(Tensor grad_output, Tensor self, Tensor weight, int[2] kernel_size, int[2] stride, int[2] padding, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, ::std::array, at::Tensor &, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad_output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + dynamic_type: ::std::array + is_nullable: false + name: output_mask + type: ::std::array + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - allocate: true + annotation: c! + dynamic_type: at::Tensor + is_nullable: false + name: out2 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out2 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: conv_depthwise3d_out + operator_name: conv_depthwise3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::conv_depthwise3d.out(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias, int[3] stride, SymInt[3] padding, int[3] dilation, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_dilated2d_out + operator_name: slow_conv_dilated2d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_dilated2d.out(Tensor self, Tensor weight, int[2] kernel_size, Tensor? bias=None, int[2] stride=1, SymInt[2] padding=0, int[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 2 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 2 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 2 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 2 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: slow_conv_dilated3d_out + operator_name: slow_conv_dilated3d + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slow_conv_dilated3d.out(Tensor self, Tensor weight, int[3] kernel_size, Tensor? bias=None, int[3] stride=1, SymInt[3] padding=0, int[3] dilation=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, at::IntArrayRef, const c10::optional &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: kernel_size + size: 3 + type: at::IntArrayRef + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: bias + type: const c10::optional & + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + size: 3 + type: at::IntArrayRef + - annotation: null + default: 0 + dynamic_type: at::IntArrayRef + is_nullable: false + name: padding + size: 3 + type: at::IntArrayRef + - annotation: null + default: 1 + dynamic_type: at::IntArrayRef + is_nullable: false + name: dilation + size: 3 + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: isinf_out + operator_name: isinf + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::isinf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: linalg_matrix_exp_out + operator_name: linalg_matrix_exp + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::linalg_matrix_exp.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_optional_intlist_out + operator_name: _test_optional_intlist + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_optional_intlist.out(Tensor values, int[]? addends, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + type: at::OptionalIntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_optional_filled_intlist_out + operator_name: _test_optional_filled_intlist + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_optional_filled_intlist.out(Tensor values, int[2]? addends, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + size: 2 + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::OptionalIntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: true + name: addends + size: 2 + type: at::OptionalIntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_optional_floatlist_out + operator_name: _test_optional_floatlist + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_optional_floatlist.out(Tensor values, float[]? addends, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: addends + type: c10::optional> + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::optional>, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: values + type: const at::Tensor & + - annotation: null + dynamic_type: at::ArrayRef + is_nullable: true + name: addends + type: c10::optional> + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_warn_in_autograd_out + operator_name: _test_warn_in_autograd + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_warn_in_autograd.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_autograd_multiple_dispatch_out + operator_name: _test_autograd_multiple_dispatch + overload_name: fullcoverage_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_autograd_multiple_dispatch.fullcoverage_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _test_autograd_multiple_dispatch_view_copy_out + operator_name: _test_autograd_multiple_dispatch_view_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_test_autograd_multiple_dispatch_view_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: segment_reduce_out + operator_name: segment_reduce + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::segment_reduce.out(Tensor data, str reduce, *, Tensor? lengths=None, Tensor? indices=None, Tensor? offsets=None, int axis=0, bool unsafe=False, Scalar? initial=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: indices + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unsafe + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, c10::string_view, const c10::optional &, const c10::optional &, const c10::optional &, int64_t, bool, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: indices + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: unsafe + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _segment_reduce_backward_out + operator_name: _segment_reduce_backward + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_segment_reduce_backward.out(Tensor grad, Tensor output, Tensor data, str reduce, *, Tensor? lengths=None, Tensor? offsets=None, int axis=0, Scalar? initial=None, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::string_view, const c10::optional &, const c10::optional &, int64_t, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: grad + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: output + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: data + type: const at::Tensor & + - annotation: null + dynamic_type: c10::string_view + is_nullable: false + name: reduce + type: c10::string_view + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: lengths + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: offsets + type: const c10::optional & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + kwarg_only: true + name: axis + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: const at::Scalar & + is_nullable: true + kwarg_only: true + name: initial + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _nested_tensor_from_tensor_list_out + operator_name: _nested_tensor_from_tensor_list + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_nested_tensor_from_tensor_list.out(Tensor[] list, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: list + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: pin_memory + type: c10::optional + schema_order_cpp_signature: at::Tensor & (at::TensorList, c10::optional, c10::optional, c10::optional, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: list + type: at::TensorList + - annotation: null + default: c10::nullopt + dynamic_type: at::ScalarType + is_nullable: true + name: dtype + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Layout + is_nullable: true + name: layout + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: at::Device + is_nullable: true + name: device + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: bool + is_nullable: true + name: pin_memory + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fw_primal_copy_out + operator_name: _fw_primal_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fw_primal_copy.out(Tensor self, int level, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _make_dual_copy_out + operator_name: _make_dual_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_make_dual_copy.out(Tensor primal, Tensor tangent, int level, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: primal + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tangent + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: primal + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: tangent + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: level + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_as_real_copy_out + operator_name: view_as_real_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_as_real_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_as_complex_copy_out + operator_name: view_as_complex_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_as_complex_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _conj_copy_out + operator_name: _conj_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_conj_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _neg_view_copy_out + operator_name: _neg_view_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_neg_view_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: as_strided_copy_out + operator_name: as_strided_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::as_strided_copy.out(Tensor self, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: storage_offset + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _sparse_broadcast_to_copy_out + operator_name: _sparse_broadcast_to_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_sparse_broadcast_to_copy.out(Tensor self, int[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: diagonal_copy_out + operator_name: diagonal_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::diagonal_copy.out(Tensor self, int offset=0, int dim1=0, int dim2=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: offset + type: int64_t + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: dim2 + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: expand_copy_out + operator_name: expand_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::expand_copy.out(Tensor self, SymInt[] size, *, bool implicit=False, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: implicit + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + default: false + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: implicit + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: permute_copy_out + operator_name: permute_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::permute_copy.out(Tensor self, int[] dims, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dims + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _reshape_alias_copy_out + operator_name: _reshape_alias_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_reshape_alias_copy.out(Tensor self, SymInt[] size, SymInt[] stride, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: stride + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: select_copy_out + operator_name: select_copy + overload_name: int_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::select_copy.int_out(Tensor self, int dim, SymInt index, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: index + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: detach_copy_out + operator_name: detach_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::detach_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: slice_copy_out + operator_name: slice_copy + overload_name: Tensor_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::slice_copy.Tensor_out(Tensor self, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, c10::optional, c10::optional, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: 0 + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: start + type: c10::optional + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: end + type: c10::optional + - annotation: null + default: 1 + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_copy_out + operator_name: squeeze_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_copy_out + operator_name: squeeze_copy + overload_name: dim_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_copy.dim_out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: squeeze_copy_out + operator_name: squeeze_copy + overload_name: dims_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::squeeze_copy.dims_out(Tensor self, int[] dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: dim + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: t_copy_out + operator_name: t_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::t_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: transpose_copy_out + operator_name: transpose_copy + overload_name: int_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::transpose_copy.int_out(Tensor self, int dim0, int dim1, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim0 + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim1 + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unsqueeze_copy_out + operator_name: unsqueeze_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unsqueeze_copy.out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dim + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _indices_copy_out + operator_name: _indices_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _values_copy_out + operator_name: _values_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_values_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: indices_copy_out + operator_name: indices_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: values_copy_out + operator_name: values_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::values_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: crow_indices_copy_out + operator_name: crow_indices_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::crow_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: col_indices_copy_out + operator_name: col_indices_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::col_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: ccol_indices_copy_out + operator_name: ccol_indices_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::ccol_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: row_indices_copy_out + operator_name: row_indices_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::row_indices_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_copy_out + operator_name: view_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_copy.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::IntArrayRef + is_nullable: false + name: size + type: at::IntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: view_copy_out + operator_name: view_copy + overload_name: dtype_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::view_copy.dtype_out(Tensor self, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::ScalarType, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: at::ScalarType + is_nullable: false + name: dtype + type: at::ScalarType + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: unfold_copy_out + operator_name: unfold_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::unfold_copy.out(Tensor self, int dimension, int size, int step, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, int64_t, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: dimension + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: size + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: step + type: int64_t + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: alias_copy_out + operator_name: alias_copy + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::alias_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: to_padded_tensor_out + operator_name: to_padded_tensor + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::to_padded_tensor.out(Tensor self, float padding, SymInt[]? output_size=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: padding + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, double, at::OptionalIntArrayRef, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + name: padding + type: double + - annotation: null + default: c10::nullopt + dynamic_type: at::IntArrayRef + is_nullable: true + name: output_size + type: at::OptionalIntArrayRef + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _transformer_encoder_layer_fwd_out + operator_name: _transformer_encoder_layer_fwd + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_transformer_encoder_layer_fwd.out(Tensor src, int embed_dim, int num_heads, Tensor qkv_weight, Tensor qkv_bias, Tensor proj_weight, Tensor proj_bias, bool use_gelu, bool norm_first, float eps, Tensor norm_weight_1, Tensor norm_bias_1, Tensor norm_weight_2, Tensor norm_bias_2, Tensor ffn_weight_1, Tensor ffn_bias_1, Tensor ffn_weight_2, Tensor ffn_bias_2, Tensor? mask=None, int? mask_type=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: use_gelu + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: norm_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, int64_t, int64_t, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool, double, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, c10::optional, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: src + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_heads + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + dynamic_type: bool + is_nullable: false + name: use_gelu + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + name: norm_first + type: bool + - annotation: null + dynamic_type: double + is_nullable: false + name: eps + type: double + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: norm_bias_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_1 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_weight_2 + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: ffn_bias_2 + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _native_multi_head_attention_out + operator_name: _native_multi_head_attention + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_native_multi_head_attention.out(Tensor query, Tensor key, Tensor value, int embed_dim, int num_head, Tensor qkv_weight, Tensor qkv_bias, Tensor proj_weight, Tensor proj_bias, Tensor? mask=None, bool need_weights=True, bool average_attn_weights=True, int? mask_type=None, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: need_weights + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: average_attn_weights + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + schema_order_cpp_signature: ::std::tuple (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, bool, bool, c10::optional, at::Tensor &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: need_weights + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: average_attn_weights + type: bool + - annotation: null + default: c10::nullopt + dynamic_type: int64_t + is_nullable: true + name: mask_type + type: c10::optional + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out0 + output: true + type: at::Tensor & + - allocate: true + annotation: b! + dynamic_type: at::Tensor + is_nullable: false + name: out1 + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out0 + type: at::Tensor & + - dynamic_type: at::Tensor + name: out1 + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _triton_scaled_dot_attention_out + operator_name: _triton_scaled_dot_attention + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_triton_scaled_dot_attention.out(Tensor q, Tensor k, Tensor v, float dropout_p=0.0, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: k + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, double, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: q + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: k + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: v + type: const at::Tensor & + - annotation: null + default: 0.0 + dynamic_type: double + is_nullable: false + name: dropout_p + type: double + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _triton_multi_head_attention_out + operator_name: _triton_multi_head_attention + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_triton_multi_head_attention.out(Tensor query, Tensor key, Tensor value, int embed_dim, int num_head, Tensor qkv_weight, Tensor qkv_bias, Tensor proj_weight, Tensor proj_bias, Tensor? mask=None, *, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, int64_t, int64_t, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: query + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: key + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: value + type: const at::Tensor & + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: embed_dim + type: int64_t + - annotation: null + dynamic_type: int64_t + is_nullable: false + name: num_head + type: int64_t + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: qkv_bias + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_weight + type: const at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: proj_bias + type: const at::Tensor & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + name: mask + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _foobar_out + operator_name: _foobar + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_foobar.out(Tensor self, bool arg1=True, bool arg2=True, *, bool arg3=True, Tensor(a!) out) -> Tensor(a!) + arguments: + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg1 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg2 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: arg3 + type: bool + schema_order_cpp_signature: at::Tensor & (const at::Tensor &, bool, bool, bool, at::Tensor &) + schema_order_arguments: + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + name: self + type: const at::Tensor & + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg1 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + name: arg2 + type: bool + - annotation: null + default: true + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: arg3 + type: bool + - allocate: true + annotation: a! + dynamic_type: at::Tensor + is_nullable: false + name: out + output: true + type: at::Tensor & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::Tensor + name: out + type: at::Tensor & + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adam_out + operator_name: _fused_adam + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adam.out(Tensor[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, float lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, double, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adam + operator_name: _fused_adam + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adam(Tensor[] self, Tensor[] grads, Tensor[] exp_avgs, Tensor[] exp_avg_sqs, Tensor[] max_exp_avg_sqs, Tensor[] state_steps, *, float lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> (Tensor[] self_out, Tensor[] grads_out, Tensor[] exp_avgs_out, Tensor[] exp_avg_sqs_out, Tensor[] max_exp_avg_sqs_out) + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple<::std::vector,::std::vector,::std::vector,::std::vector,::std::vector> (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, double, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + field_name: self_out + name: self_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: grads_out + name: grads_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avgs_out + name: exp_avgs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avg_sqs_out + name: exp_avg_sqs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: max_exp_avg_sqs_out + name: max_exp_avg_sqs_out + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adam_out + operator_name: _fused_adam + overload_name: tensor_lr_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adam.tensor_lr_out(Tensor[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, Tensor lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adam + operator_name: _fused_adam + overload_name: tensor_lr + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adam.tensor_lr(Tensor[] self, Tensor[] grads, Tensor[] exp_avgs, Tensor[] exp_avg_sqs, Tensor[] max_exp_avg_sqs, Tensor[] state_steps, *, Tensor lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> (Tensor[] self_out, Tensor[] grads_out, Tensor[] exp_avgs_out, Tensor[] exp_avg_sqs_out, Tensor[] max_exp_avg_sqs_out) + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple<::std::vector,::std::vector,::std::vector,::std::vector,::std::vector> (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + field_name: self_out + name: self_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: grads_out + name: grads_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avgs_out + name: exp_avgs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avg_sqs_out + name: exp_avg_sqs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: max_exp_avg_sqs_out + name: max_exp_avg_sqs_out + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adamw_out + operator_name: _fused_adamw + overload_name: out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adamw.out(Tensor[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, float lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, double, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adamw + operator_name: _fused_adamw + overload_name: '' + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adamw(Tensor[] self, Tensor[] grads, Tensor[] exp_avgs, Tensor[] exp_avg_sqs, Tensor[] max_exp_avg_sqs, Tensor[] state_steps, *, float lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> (Tensor[] self_out, Tensor[] grads_out, Tensor[] exp_avgs_out, Tensor[] exp_avg_sqs_out, Tensor[] max_exp_avg_sqs_out) + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple<::std::vector,::std::vector,::std::vector,::std::vector,::std::vector> (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, double, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: lr + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + field_name: self_out + name: self_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: grads_out + name: grads_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avgs_out + name: exp_avgs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avg_sqs_out + name: exp_avg_sqs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: max_exp_avg_sqs_out + name: max_exp_avg_sqs_out + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adamw_out + operator_name: _fused_adamw + overload_name: tensor_lr_out + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adamw.tensor_lr_out(Tensor[] self, Tensor(b!)[] grads, Tensor(c!)[] exp_avgs, Tensor(d!)[] exp_avg_sqs, Tensor(e!)[] max_exp_avg_sqs, Tensor[] state_steps, *, Tensor lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None, Tensor(a!)[] out) -> () + arguments: + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: void (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &, at::TensorList) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: b! + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: c! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: d! + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: e! + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + - allocate: true + annotation: a! + dynamic_type: at::TensorList + is_nullable: false + name: out + output: true + type: at::TensorList + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: [] + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false +- name: _fused_adamw + operator_name: _fused_adamw + overload_name: tensor_lr + manual_kernel_registration: false + category_override: '' + schema_string: aten::_fused_adamw.tensor_lr(Tensor[] self, Tensor[] grads, Tensor[] exp_avgs, Tensor[] exp_avg_sqs, Tensor[] max_exp_avg_sqs, Tensor[] state_steps, *, Tensor lr, float beta1, float beta2, float weight_decay, float eps, bool amsgrad, bool maximize, Tensor? grad_scale=None, Tensor? found_inf=None) -> (Tensor[] self_out, Tensor[] grads_out, Tensor[] exp_avgs_out, Tensor[] exp_avg_sqs_out, Tensor[] max_exp_avg_sqs_out) + arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + schema_order_cpp_signature: ::std::tuple<::std::vector,::std::vector,::std::vector,::std::vector,::std::vector> (at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, at::TensorList, const at::Tensor &, double, double, double, double, bool, bool, const c10::optional &, const c10::optional &) + schema_order_arguments: + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: self + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: grads + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avgs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: max_exp_avg_sqs + type: at::TensorList + - annotation: null + dynamic_type: at::TensorList + is_nullable: false + name: state_steps + type: at::TensorList + - annotation: null + dynamic_type: at::Tensor + is_nullable: false + kwarg_only: true + name: lr + type: const at::Tensor & + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta1 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: beta2 + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: weight_decay + type: double + - annotation: null + dynamic_type: double + is_nullable: false + kwarg_only: true + name: eps + type: double + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: amsgrad + type: bool + - annotation: null + dynamic_type: bool + is_nullable: false + kwarg_only: true + name: maximize + type: bool + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: grad_scale + type: const c10::optional & + - annotation: null + default: '{}' + dynamic_type: at::Tensor + is_nullable: true + kwarg_only: true + name: found_inf + type: const c10::optional & + method_of: + - Type + - namespace + mode: native + python_module: '' + returns: + - dynamic_type: at::TensorList + field_name: self_out + name: self_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: grads_out + name: grads_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avgs_out + name: exp_avgs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: exp_avg_sqs_out + name: exp_avg_sqs_out + type: ::std::vector + - dynamic_type: at::TensorList + field_name: max_exp_avg_sqs_out + name: max_exp_avg_sqs_out + type: ::std::vector + inplace: false + is_factory_method: false + abstract: true + device_guard: false + with_gil: false + deprecated: false + has_math_kernel: false diff --git a/libtch/c-generated.go b/libtch/c-generated.go index 5b6a4fd..6c9e656 100644 --- a/libtch/c-generated.go +++ b/libtch/c-generated.go @@ -237,13 +237,6 @@ func Atg_CholeskySolveHelperOut(ptr *Ctensor, out Ctensor, self Ctensor, a Ctens cupper := *(*C.int)(unsafe.Pointer(&upper)) C.atg__cholesky_solve_helper_out(ptr, out, self, a, cupper) } -func Atg_ChunkGradOutputsEfficientAttention(query Ctensor, key Ctensor, value Ctensor, isCausal int32) bool{ -cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) - cResult := C.atg__chunk_grad_outputs_efficient_attention(query, key, value, cisCausal) - cbool := *(*int)(unsafe.Pointer(&cResult)) - if cbool == 1{return true} - return false -} func Atg_Coalesce(ptr *Ctensor, self Ctensor){ C.atg__coalesce(ptr, self) } @@ -400,6 +393,13 @@ func Atg_CopyFromOut(ptr *Ctensor, out Ctensor, self Ctensor, dst Ctensor, nonBl cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking)) C.atg__copy_from_out(ptr, out, self, dst, cnonBlocking) } +func Atg_CsltCompress(ptr *Ctensor, input Ctensor){ + C.atg__cslt_compress(ptr, input) +} +func Atg_CsltSparseMm(ptr *Ctensor, compressedA Ctensor, denseB Ctensor, bias Ctensor, transposeResult int32){ +ctransposeResult := *(*C.int)(unsafe.Pointer(&transposeResult)) + C.atg__cslt_sparse_mm(ptr, compressedA, denseB, bias, ctransposeResult) +} func Atg_CtcLoss(ptr *Ctensor, logProbs Ctensor, targets Ctensor, inputLengthsData []int64, inputLengthsLen int, targetLengthsData []int64, targetLengthsLen int, blank int64, zeroInfinity int32){ cinputLengthsDataPtr := (*C.int64_t)(unsafe.Pointer(&inputLengthsData[0])) cinputLengthsLen := *(*C.int)(unsafe.Pointer(&inputLengthsLen)) @@ -549,16 +549,6 @@ cbatchSizesDataPtr := (*C.int64_t)(unsafe.Pointer(&batchSizesData[0])) cbatchSizesLen := *(*C.int)(unsafe.Pointer(&batchSizesLen)) C.atg__cudnn_rnn_out(ptr, out0, out1, out2, out3, out4, input, cweightDataPtr, cweightLen, cweightStride0, weightBuf, hx, cx, cmode, chiddenSize, cprojSize, cnumLayers, cbatchFirst, cdropout, ctrain, cbidirectional, cbatchSizesDataPtr, cbatchSizesLen, dropoutState) } -func Atg_CufftGetPlanCacheMaxSize(deviceIndex int64) int64{ -cdeviceIndex := *(*C.int64_t)(unsafe.Pointer(&deviceIndex)) - cResult := C.atg__cufft_get_plan_cache_max_size(cdeviceIndex) - return *(*int64)(unsafe.Pointer(&cResult)) -} -func Atg_CufftGetPlanCacheSize(deviceIndex int64) int64{ -cdeviceIndex := *(*C.int64_t)(unsafe.Pointer(&deviceIndex)) - cResult := C.atg__cufft_get_plan_cache_size(cdeviceIndex) - return *(*int64)(unsafe.Pointer(&cResult)) -} func Atg_DebugHasInternalOverlap(self Ctensor) int64{ cResult := C.atg__debug_has_internal_overlap(self) return *(*int64)(unsafe.Pointer(&cResult)) @@ -581,10 +571,17 @@ func Atg_DirichletGrad(ptr *Ctensor, x Ctensor, alpha Ctensor, total Ctensor){ func Atg_DirichletGradOut(ptr *Ctensor, out Ctensor, x Ctensor, alpha Ctensor, total Ctensor){ C.atg__dirichlet_grad_out(ptr, out, x, alpha, total) } -func Atg_EfficientAttentionBackward(ptr *Ctensor, gradOut_ Ctensor, query Ctensor, key Ctensor, value Ctensor, out Ctensor, logsumexp Ctensor, isCausal int32, chunkGradOutputs int32){ -cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) -cchunkGradOutputs := *(*C.int)(unsafe.Pointer(&chunkGradOutputs)) - C.atg__efficient_attention_backward(ptr, gradOut_, query, key, value, out, logsumexp, cisCausal, cchunkGradOutputs) +func Atg_EfficientAttentionBackward(ptr *Ctensor, gradOut_ Ctensor, query Ctensor, key Ctensor, value Ctensor, bias Ctensor, out Ctensor, cuSeqlensQ Ctensor, cuSeqlensK Ctensor, maxSeqlenK int64, maxSeqlenQ int64, logsumexp Ctensor, dropoutP float64, philoxSeed Ctensor, philoxOffset Ctensor, customMaskType int64, biasRequiresGrad int32, scaleVal float64, scaleNull int, numSplitsKeyVal int64, numSplitsKeyNull int){ +cmaxSeqlenK := *(*C.int64_t)(unsafe.Pointer(&maxSeqlenK)) +cmaxSeqlenQ := *(*C.int64_t)(unsafe.Pointer(&maxSeqlenQ)) +cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) +ccustomMaskType := *(*C.int64_t)(unsafe.Pointer(&customMaskType)) +cbiasRequiresGrad := *(*C.int)(unsafe.Pointer(&biasRequiresGrad)) +cscaleVal := *(*C.double)(unsafe.Pointer(&scaleVal)) +cscaleNull := *(*C.uint8_t)(unsafe.Pointer(&scaleNull)) +cnumSplitsKeyVal := *(*C.int64_t)(unsafe.Pointer(&numSplitsKeyVal)) +cnumSplitsKeyNull := *(*C.uint8_t)(unsafe.Pointer(&numSplitsKeyNull)) + C.atg__efficient_attention_backward(ptr, gradOut_, query, key, value, bias, out, cuSeqlensQ, cuSeqlensK, cmaxSeqlenK, cmaxSeqlenQ, logsumexp, cdropoutP, philoxSeed, philoxOffset, ccustomMaskType, cbiasRequiresGrad, cscaleVal, cscaleNull, cnumSplitsKeyVal, cnumSplitsKeyNull) } func Atg_Efficientzerotensor(ptr *Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){ csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) @@ -796,14 +793,20 @@ cnormalization := *(*C.int64_t)(unsafe.Pointer(&normalization)) conesided := *(*C.int)(unsafe.Pointer(&onesided)) C.atg__fft_r2c_out(ptr, out, self, cdimDataPtr, cdimLen, cnormalization, conesided) } -func Atg_FlashAttentionBackward(ptr *Ctensor, gradOut Ctensor, query Ctensor, key Ctensor, value Ctensor, out Ctensor, logsumexp Ctensor, cumSeqQ Ctensor, cumSeqK Ctensor, maxQ int64, maxK int64, dropoutP float64, isCausal int32, philoxSeed int64, philoxOffset int64){ +func Atg_FillMemEffDropoutMask_(ptr *Ctensor, self Ctensor, dropoutP float64, seed int64, offset int64){ +cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) +cseed := *(*C.int64_t)(unsafe.Pointer(&seed)) +coffset := *(*C.int64_t)(unsafe.Pointer(&offset)) + C.atg__fill_mem_eff_dropout_mask_(ptr, self, cdropoutP, cseed, coffset) +} +func Atg_FlashAttentionBackward(ptr *Ctensor, gradOut Ctensor, query Ctensor, key Ctensor, value Ctensor, out Ctensor, logsumexp Ctensor, cumSeqQ Ctensor, cumSeqK Ctensor, maxQ int64, maxK int64, dropoutP float64, isCausal int32, philoxSeed Ctensor, philoxOffset Ctensor, scaleVal float64, scaleNull int){ cmaxQ := *(*C.int64_t)(unsafe.Pointer(&maxQ)) cmaxK := *(*C.int64_t)(unsafe.Pointer(&maxK)) cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) -cphiloxSeed := *(*C.int64_t)(unsafe.Pointer(&philoxSeed)) -cphiloxOffset := *(*C.int64_t)(unsafe.Pointer(&philoxOffset)) - C.atg__flash_attention_backward(ptr, gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, cmaxQ, cmaxK, cdropoutP, cisCausal, cphiloxSeed, cphiloxOffset) +cscaleVal := *(*C.double)(unsafe.Pointer(&scaleVal)) +cscaleNull := *(*C.uint8_t)(unsafe.Pointer(&scaleNull)) + C.atg__flash_attention_backward(ptr, gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, cmaxQ, cmaxK, cdropoutP, cisCausal, philoxSeed, philoxOffset, cscaleVal, cscaleNull) } func Atg_Foobar(ptr *Ctensor, self Ctensor, arg1 int32, arg2 int32, arg3 int32){ carg1 := *(*C.int)(unsafe.Pointer(&arg1)) @@ -817,6 +820,26 @@ carg2 := *(*C.int)(unsafe.Pointer(&arg2)) carg3 := *(*C.int)(unsafe.Pointer(&arg3)) C.atg__foobar_out(ptr, out, self, carg1, carg2, carg3) } +func Atg_FunctionalAssertAsync(ptr *Ctensor, self Ctensor, assertMsg string, depToken Ctensor){ +cassertMsg := C.CString(assertMsg) +assertMsgLen := len(assertMsg) +cassertMsgLen := *(*C.int)(unsafe.Pointer(&assertMsgLen)) + C.atg__functional_assert_async(ptr, self, cassertMsg, cassertMsgLen, depToken) +} +func Atg_FunctionalSymConstrainRange(ptr *Ctensor, size Cscalar, minVal int64, minNull int, maxVal int64, maxNull int, depToken Ctensor){ +cminVal := *(*C.int64_t)(unsafe.Pointer(&minVal)) +cminNull := *(*C.uint8_t)(unsafe.Pointer(&minNull)) +cmaxVal := *(*C.int64_t)(unsafe.Pointer(&maxVal)) +cmaxNull := *(*C.uint8_t)(unsafe.Pointer(&maxNull)) + C.atg__functional_sym_constrain_range(ptr, size , cminVal, cminNull, cmaxVal, cmaxNull, depToken) +} +func Atg_FunctionalSymConstrainRangeForSize(ptr *Ctensor, size Cscalar, minVal int64, minNull int, maxVal int64, maxNull int, depToken Ctensor){ +cminVal := *(*C.int64_t)(unsafe.Pointer(&minVal)) +cminNull := *(*C.uint8_t)(unsafe.Pointer(&minNull)) +cmaxVal := *(*C.int64_t)(unsafe.Pointer(&maxVal)) +cmaxNull := *(*C.uint8_t)(unsafe.Pointer(&maxNull)) + C.atg__functional_sym_constrain_range_for_size(ptr, size , cminVal, cminNull, cmaxVal, cmaxNull, depToken) +} func Atg_FusedDropout(ptr *Ctensor, self Ctensor, p float64){ cp := *(*C.double)(unsafe.Pointer(&p)) C.atg__fused_dropout(ptr, self, cp) @@ -852,10 +875,12 @@ cperRowFakeQuant := *(*C.int)(unsafe.Pointer(&perRowFakeQuant)) csymmetricQuant := *(*C.int)(unsafe.Pointer(&symmetricQuant)) C.atg__fused_moving_avg_obs_fq_helper_out(ptr, out0, out1, self, observerOn, fakeQuantOn, runningMin, runningMax, scale, zeroPoint, caveragingConst, cquantMin, cquantMax, cchAxis, cperRowFakeQuant, csymmetricQuant) } -func Atg_FusedSdpChoice(query Ctensor, key Ctensor, value Ctensor, attnMask Ctensor, dropoutP float64, isCausal int32) int64{ +func Atg_FusedSdpChoice(query Ctensor, key Ctensor, value Ctensor, attnMask Ctensor, dropoutP float64, isCausal int32, scaleVal float64, scaleNull int) int64{ cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) - cResult := C.atg__fused_sdp_choice(query, key, value, attnMask, cdropoutP, cisCausal) +cscaleVal := *(*C.double)(unsafe.Pointer(&scaleVal)) +cscaleNull := *(*C.uint8_t)(unsafe.Pointer(&scaleNull)) + cResult := C.atg__fused_sdp_choice(query, key, value, attnMask, cdropoutP, cisCausal, cscaleVal, cscaleNull) return *(*int64)(unsafe.Pointer(&cResult)) } func Atg_FwPrimal(ptr *Ctensor, self Ctensor, level int64){ @@ -954,6 +979,12 @@ func Atg_IndicesCopy(ptr *Ctensor, self Ctensor){ func Atg_IndicesCopyOut(ptr *Ctensor, out Ctensor, self Ctensor){ C.atg__indices_copy_out(ptr, out, self) } +func Atg_IntMm(ptr *Ctensor, self Ctensor, mat2 Ctensor){ + C.atg__int_mm(ptr, self, mat2) +} +func Atg_IntMmOut(ptr *Ctensor, out Ctensor, self Ctensor, mat2 Ctensor){ + C.atg__int_mm_out(ptr, out, self, mat2) +} func Atg_IsAllTrue(ptr *Ctensor, self Ctensor){ C.atg__is_all_true(ptr, self) } @@ -1077,6 +1108,11 @@ cpivot := *(*C.int)(unsafe.Pointer(&pivot)) ccheckErrors := *(*C.int)(unsafe.Pointer(&checkErrors)) C.atg__lu_with_info(ptr, self, cpivot, ccheckErrors) } +func Atg_MakeDepToken(ptr *Ctensor, optionsKind int32, optionsDevice int32){ +coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) +coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) + C.atg__make_dep_token(ptr, coptionsKind, coptionsDevice) +} func Atg_MakeDual(ptr *Ctensor, primal Ctensor, tangent Ctensor, level int64){ clevel := *(*C.int64_t)(unsafe.Pointer(&level)) C.atg__make_dual(ptr, primal, tangent, clevel) @@ -1232,26 +1268,22 @@ cmomentum := *(*C.double)(unsafe.Pointer(&momentum)) ceps := *(*C.double)(unsafe.Pointer(&eps)) C.atg__native_batch_norm_legit_no_stats_out(ptr, out, saveMean, saveInvstd, input, weight, bias, ctraining, cmomentum, ceps) } +func Atg_NativeBatchNormLegitNoTraining(ptr *Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64, eps float64){ +cmomentum := *(*C.double)(unsafe.Pointer(&momentum)) +ceps := *(*C.double)(unsafe.Pointer(&eps)) + C.atg__native_batch_norm_legit_no_training(ptr, input, weight, bias, runningMean, runningVar, cmomentum, ceps) +} +func Atg_NativeBatchNormLegitNoTrainingOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, out2 Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, momentum float64, eps float64){ +cmomentum := *(*C.double)(unsafe.Pointer(&momentum)) +ceps := *(*C.double)(unsafe.Pointer(&eps)) + C.atg__native_batch_norm_legit_no_training_out(ptr, out0, out1, out2, input, weight, bias, runningMean, runningVar, cmomentum, ceps) +} func Atg_NativeBatchNormLegitOut(ptr *Ctensor, out Ctensor, saveMean Ctensor, saveInvstd Ctensor, input Ctensor, weight Ctensor, bias Ctensor, runningMean Ctensor, runningVar Ctensor, training int32, momentum float64, eps float64){ ctraining := *(*C.int)(unsafe.Pointer(&training)) cmomentum := *(*C.double)(unsafe.Pointer(&momentum)) ceps := *(*C.double)(unsafe.Pointer(&eps)) C.atg__native_batch_norm_legit_out(ptr, out, saveMean, saveInvstd, input, weight, bias, runningMean, runningVar, ctraining, cmomentum, ceps) } -func Atg_NativeDecoderOnlyMultiHeadAttention(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, embedDim int64, numHead int64, qkvWeight Ctensor, qkvBias Ctensor, projWeight Ctensor, projBias Ctensor, mask Ctensor, incrKey Ctensor, incrValue Ctensor, needWeights int32, averageAttnWeights int32){ -cembedDim := *(*C.int64_t)(unsafe.Pointer(&embedDim)) -cnumHead := *(*C.int64_t)(unsafe.Pointer(&numHead)) -cneedWeights := *(*C.int)(unsafe.Pointer(&needWeights)) -caverageAttnWeights := *(*C.int)(unsafe.Pointer(&averageAttnWeights)) - C.atg__native_decoder_only_multi_head_attention(ptr, query, key, value, cembedDim, cnumHead, qkvWeight, qkvBias, projWeight, projBias, mask, incrKey, incrValue, cneedWeights, caverageAttnWeights) -} -func Atg_NativeDecoderOnlyMultiHeadAttentionOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, out2 Ctensor, out3 Ctensor, query Ctensor, key Ctensor, value Ctensor, embedDim int64, numHead int64, qkvWeight Ctensor, qkvBias Ctensor, projWeight Ctensor, projBias Ctensor, mask Ctensor, incrKey Ctensor, incrValue Ctensor, needWeights int32, averageAttnWeights int32){ -cembedDim := *(*C.int64_t)(unsafe.Pointer(&embedDim)) -cnumHead := *(*C.int64_t)(unsafe.Pointer(&numHead)) -cneedWeights := *(*C.int)(unsafe.Pointer(&needWeights)) -caverageAttnWeights := *(*C.int)(unsafe.Pointer(&averageAttnWeights)) - C.atg__native_decoder_only_multi_head_attention_out(ptr, out0, out1, out2, out3, query, key, value, cembedDim, cnumHead, qkvWeight, qkvBias, projWeight, projBias, mask, incrKey, incrValue, cneedWeights, caverageAttnWeights) -} func Atg_NativeMultiHeadAttention(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, embedDim int64, numHead int64, qkvWeight Ctensor, qkvBias Ctensor, projWeight Ctensor, projBias Ctensor, mask Ctensor, needWeights int32, averageAttnWeights int32, maskTypeVal int64, maskTypeNull int){ cembedDim := *(*C.int64_t)(unsafe.Pointer(&embedDim)) cnumHead := *(*C.int64_t)(unsafe.Pointer(&numHead)) @@ -1304,20 +1336,14 @@ cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) C.atg__nested_sum_backward(ptr, grad, self, cdimDataPtr, cdimLen, ckeepdim) } -func Atg_NestedViewFromBuffer(ptr *Ctensor, self Ctensor, nestedSize Ctensor, nestedStrides Ctensor, offsetsData []int64, offsetsLen int){ -coffsetsDataPtr := (*C.int64_t)(unsafe.Pointer(&offsetsData[0])) -coffsetsLen := *(*C.int)(unsafe.Pointer(&offsetsLen)) - C.atg__nested_view_from_buffer(ptr, self, nestedSize, nestedStrides, coffsetsDataPtr, coffsetsLen) +func Atg_NestedViewFromBuffer(ptr *Ctensor, self Ctensor, nestedSize Ctensor, nestedStrides Ctensor, offsets Ctensor){ + C.atg__nested_view_from_buffer(ptr, self, nestedSize, nestedStrides, offsets) } -func Atg_NestedViewFromBufferCopy(ptr *Ctensor, self Ctensor, nestedSize Ctensor, nestedStrides Ctensor, offsetsData []int64, offsetsLen int){ -coffsetsDataPtr := (*C.int64_t)(unsafe.Pointer(&offsetsData[0])) -coffsetsLen := *(*C.int)(unsafe.Pointer(&offsetsLen)) - C.atg__nested_view_from_buffer_copy(ptr, self, nestedSize, nestedStrides, coffsetsDataPtr, coffsetsLen) +func Atg_NestedViewFromBufferCopy(ptr *Ctensor, self Ctensor, nestedSize Ctensor, nestedStrides Ctensor, offsets Ctensor){ + C.atg__nested_view_from_buffer_copy(ptr, self, nestedSize, nestedStrides, offsets) } -func Atg_NestedViewFromBufferCopyOut(ptr *Ctensor, out Ctensor, self Ctensor, nestedSize Ctensor, nestedStrides Ctensor, offsetsData []int64, offsetsLen int){ -coffsetsDataPtr := (*C.int64_t)(unsafe.Pointer(&offsetsData[0])) -coffsetsLen := *(*C.int)(unsafe.Pointer(&offsetsLen)) - C.atg__nested_view_from_buffer_copy_out(ptr, out, self, nestedSize, nestedStrides, coffsetsDataPtr, coffsetsLen) +func Atg_NestedViewFromBufferCopyOut(ptr *Ctensor, out Ctensor, self Ctensor, nestedSize Ctensor, nestedStrides Ctensor, offsets Ctensor){ + C.atg__nested_view_from_buffer_copy_out(ptr, out, self, nestedSize, nestedStrides, offsets) } func Atg_NewZerosWithSameFeatureMeta(ptr *Ctensor, self Ctensor, other Ctensor, selfNumBatchDims int64){ cselfNumBatchDims := *(*C.int64_t)(unsafe.Pointer(&selfNumBatchDims)) @@ -1405,6 +1431,7 @@ func Atg_PreluKernel(ptr *Ctensor, self Ctensor, weight Ctensor){ func Atg_PreluKernelBackward(ptr *Ctensor, gradOutput Ctensor, self Ctensor, weight Ctensor){ C.atg__prelu_kernel_backward(ptr, gradOutput, self, weight) } + func Atg_RemoveBatchDim(ptr *Ctensor, self Ctensor, level int64, batchSize int64, outDim int64){ clevel := *(*C.int64_t)(unsafe.Pointer(&level)) cbatchSize := *(*C.int64_t)(unsafe.Pointer(&batchSize)) @@ -1471,35 +1498,61 @@ func Atg_SampleDirichletOut(ptr *Ctensor, out Ctensor, self Ctensor){ func Atg_SaturateWeightToFp16(ptr *Ctensor, weight Ctensor){ C.atg__saturate_weight_to_fp16(ptr, weight) } -func Atg_ScaledDotProductAttention(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, attnMask Ctensor, dropoutP float64, needAttnWeights int32, isCausal int32){ +func Atg_ScaledDotProductAttentionMath(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, attnMask Ctensor, dropoutP float64, isCausal int32, dropoutMask Ctensor, scaleVal float64, scaleNull int){ cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) -cneedAttnWeights := *(*C.int)(unsafe.Pointer(&needAttnWeights)) -cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) - C.atg__scaled_dot_product_attention(ptr, query, key, value, attnMask, cdropoutP, cneedAttnWeights, cisCausal) -} -func Atg_ScaledDotProductAttentionMath(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, attnMask Ctensor, dropoutP float64, isCausal int32, dropoutMask Ctensor){ -cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) -cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) - C.atg__scaled_dot_product_attention_math(ptr, query, key, value, attnMask, cdropoutP, cisCausal, dropoutMask) -} -func Atg_ScaledDotProductEfficientAttention(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, computeLogSumexp int32, isCausal int32){ -ccomputeLogSumexp := *(*C.int)(unsafe.Pointer(&computeLogSumexp)) -cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) - C.atg__scaled_dot_product_efficient_attention(ptr, query, key, value, ccomputeLogSumexp, cisCausal) -} -func Atg_ScaledDotProductEfficientAttentionBackward(ptr *Ctensor, gradOut_ Ctensor, query Ctensor, key Ctensor, value Ctensor, out Ctensor, logsumexp Ctensor, isCausal int32, chunkGradOutputs int32){ cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) -cchunkGradOutputs := *(*C.int)(unsafe.Pointer(&chunkGradOutputs)) - C.atg__scaled_dot_product_efficient_attention_backward(ptr, gradOut_, query, key, value, out, logsumexp, cisCausal, cchunkGradOutputs) +cscaleVal := *(*C.double)(unsafe.Pointer(&scaleVal)) +cscaleNull := *(*C.uint8_t)(unsafe.Pointer(&scaleNull)) + C.atg__scaled_dot_product_attention_math(ptr, query, key, value, attnMask, cdropoutP, cisCausal, dropoutMask, cscaleVal, cscaleNull) } -func Atg_ScaledDotProductFlashAttentionBackward(ptr *Ctensor, gradOut Ctensor, query Ctensor, key Ctensor, value Ctensor, out Ctensor, logsumexp Ctensor, cumSeqQ Ctensor, cumSeqK Ctensor, maxQ int64, maxK int64, dropoutP float64, isCausal int32, philoxSeed int64, philoxOffset int64){ +func Atg_ScaledDotProductEfficientAttention(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, attnBias Ctensor, computeLogSumexp int32, dropoutP float64, isCausal int32, scaleVal float64, scaleNull int){ +ccomputeLogSumexp := *(*C.int)(unsafe.Pointer(&computeLogSumexp)) +cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) +cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) +cscaleVal := *(*C.double)(unsafe.Pointer(&scaleVal)) +cscaleNull := *(*C.uint8_t)(unsafe.Pointer(&scaleNull)) + C.atg__scaled_dot_product_efficient_attention(ptr, query, key, value, attnBias, ccomputeLogSumexp, cdropoutP, cisCausal, cscaleVal, cscaleNull) +} +func Atg_ScaledDotProductFlashAttentionBackward(ptr *Ctensor, gradOut Ctensor, query Ctensor, key Ctensor, value Ctensor, out Ctensor, logsumexp Ctensor, cumSeqQ Ctensor, cumSeqK Ctensor, maxQ int64, maxK int64, dropoutP float64, isCausal int32, philoxSeed Ctensor, philoxOffset Ctensor, scaleVal float64, scaleNull int){ cmaxQ := *(*C.int64_t)(unsafe.Pointer(&maxQ)) cmaxK := *(*C.int64_t)(unsafe.Pointer(&maxK)) cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) -cphiloxSeed := *(*C.int64_t)(unsafe.Pointer(&philoxSeed)) -cphiloxOffset := *(*C.int64_t)(unsafe.Pointer(&philoxOffset)) - C.atg__scaled_dot_product_flash_attention_backward(ptr, gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, cmaxQ, cmaxK, cdropoutP, cisCausal, cphiloxSeed, cphiloxOffset) +cscaleVal := *(*C.double)(unsafe.Pointer(&scaleVal)) +cscaleNull := *(*C.uint8_t)(unsafe.Pointer(&scaleNull)) + C.atg__scaled_dot_product_flash_attention_backward(ptr, gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, cmaxQ, cmaxK, cdropoutP, cisCausal, philoxSeed, philoxOffset, cscaleVal, cscaleNull) +} +func Atg_ScaledMm(ptr *Ctensor, self Ctensor, mat2 Ctensor, bias Ctensor, outDtype int32, scaleA Ctensor, scaleB Ctensor, scaleResult Ctensor){ +coutDtype := *(*C.int)(unsafe.Pointer(&outDtype)) + C.atg__scaled_mm(ptr, self, mat2, bias, coutDtype, scaleA, scaleB, scaleResult) +} +func Atg_ScaledMmOut(ptr *Ctensor, out Ctensor, outAmax Ctensor, self Ctensor, mat2 Ctensor, bias Ctensor, outDtype int32, scaleA Ctensor, scaleB Ctensor, scaleResult Ctensor){ +coutDtype := *(*C.int)(unsafe.Pointer(&outDtype)) + C.atg__scaled_mm_out(ptr, out, outAmax, self, mat2, bias, coutDtype, scaleA, scaleB, scaleResult) +} +func Atg_ScatterReduce(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string, includeSelf int32){ +cdim := *(*C.int64_t)(unsafe.Pointer(&dim)) +creduce := C.CString(reduce) +reduceLen := len(reduce) +creduceLen := *(*C.int)(unsafe.Pointer(&reduceLen)) +cincludeSelf := *(*C.int)(unsafe.Pointer(&includeSelf)) + C.atg__scatter_reduce(ptr, self, cdim, index, src, creduce, creduceLen, cincludeSelf) +} +func Atg_ScatterReduce_(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string, includeSelf int32){ +cdim := *(*C.int64_t)(unsafe.Pointer(&dim)) +creduce := C.CString(reduce) +reduceLen := len(reduce) +creduceLen := *(*C.int)(unsafe.Pointer(&reduceLen)) +cincludeSelf := *(*C.int)(unsafe.Pointer(&includeSelf)) + C.atg__scatter_reduce_(ptr, self, cdim, index, src, creduce, creduceLen, cincludeSelf) +} +func Atg_ScatterReduceTwoOut(ptr *Ctensor, out Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor, reduce string, includeSelf int32){ +cdim := *(*C.int64_t)(unsafe.Pointer(&dim)) +creduce := C.CString(reduce) +reduceLen := len(reduce) +creduceLen := *(*C.int)(unsafe.Pointer(&reduceLen)) +cincludeSelf := *(*C.int)(unsafe.Pointer(&includeSelf)) + C.atg__scatter_reduce_two_out(ptr, out, self, cdim, index, src, creduce, creduceLen, cincludeSelf) } func Atg_SegmentReduceBackward(ptr *Ctensor, grad Ctensor, output Ctensor, data Ctensor, reduce string, lengths Ctensor, offsets Ctensor, axis int64, initial Cscalar){ creduce := C.CString(reduce) @@ -1610,12 +1663,13 @@ coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) C.atg__sparse_compressed_tensor_unsafe(ptr, compressedIndices, plainIndices, values, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice) } -func Atg_SparseCooTensorUnsafe(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){ +func Atg_SparseCooTensorUnsafe(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32, isCoalesced int32){ csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) -coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) - C.atg__sparse_coo_tensor_unsafe(ptr, indices, values, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice) +coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) +cisCoalesced := *(*C.int)(unsafe.Pointer(&isCoalesced)) + C.atg__sparse_coo_tensor_unsafe(ptr, indices, values, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice, cisCoalesced) } func Atg_SparseCooTensorWithDims(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){ csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) @@ -1626,21 +1680,23 @@ coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) C.atg__sparse_coo_tensor_with_dims(ptr, csparseDim, cdenseDim, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice) } -func Atg_SparseCooTensorWithDimsAndTensors(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32){ +func Atg_SparseCooTensorWithDimsAndTensors(ptr *Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32, isCoalesced int32){ csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) cdenseDim := *(*C.int64_t)(unsafe.Pointer(&denseDim)) csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) -coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) - C.atg__sparse_coo_tensor_with_dims_and_tensors(ptr, csparseDim, cdenseDim, csizeDataPtr, csizeLen, indices, values, coptionsKind, coptionsDevice) +coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) +cisCoalesced := *(*C.int)(unsafe.Pointer(&isCoalesced)) + C.atg__sparse_coo_tensor_with_dims_and_tensors(ptr, csparseDim, cdenseDim, csizeDataPtr, csizeLen, indices, values, coptionsKind, coptionsDevice, cisCoalesced) } -func Atg_SparseCooTensorWithDimsAndTensorsOut(ptr *Ctensor, out Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, indices Ctensor, values Ctensor){ +func Atg_SparseCooTensorWithDimsAndTensorsOut(ptr *Ctensor, out Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int, indices Ctensor, values Ctensor, isCoalesced int32){ csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) cdenseDim := *(*C.int64_t)(unsafe.Pointer(&denseDim)) csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) -csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) - C.atg__sparse_coo_tensor_with_dims_and_tensors_out(ptr, out, csparseDim, cdenseDim, csizeDataPtr, csizeLen, indices, values) +csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) +cisCoalesced := *(*C.int)(unsafe.Pointer(&isCoalesced)) + C.atg__sparse_coo_tensor_with_dims_and_tensors_out(ptr, out, csparseDim, cdenseDim, csizeDataPtr, csizeLen, indices, values, cisCoalesced) } func Atg_SparseCooTensorWithDimsOut(ptr *Ctensor, out Ctensor, sparseDim int64, denseDim int64, sizeData []int64, sizeLen int){ csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) @@ -1714,6 +1770,14 @@ cdim := *(*C.int64_t)(unsafe.Pointer(&dim)) chalfToFloat := *(*C.int)(unsafe.Pointer(&halfToFloat)) C.atg__sparse_log_softmax_out(ptr, out, self, cdim, chalfToFloat) } +func Atg_SparseMaskProjection(ptr *Ctensor, self Ctensor, mask Ctensor, accumulateMatches int32){ +caccumulateMatches := *(*C.int)(unsafe.Pointer(&accumulateMatches)) + C.atg__sparse_mask_projection(ptr, self, mask, caccumulateMatches) +} +func Atg_SparseMaskProjectionOut(ptr *Ctensor, out Ctensor, self Ctensor, mask Ctensor, accumulateMatches int32){ +caccumulateMatches := *(*C.int)(unsafe.Pointer(&accumulateMatches)) + C.atg__sparse_mask_projection_out(ptr, out, self, mask, caccumulateMatches) +} func Atg_SparseMm(ptr *Ctensor, sparse Ctensor, dense Ctensor){ C.atg__sparse_mm(ptr, sparse, dense) } @@ -1729,6 +1793,12 @@ reduceLen := len(reduce) creduceLen := *(*C.int)(unsafe.Pointer(&reduceLen)) C.atg__sparse_mm_reduce_impl(ptr, self, other, creduce, creduceLen) } +func Atg_SparseSemiStructuredLinear(ptr *Ctensor, input Ctensor, weight Ctensor, meta Ctensor, bias Ctensor, activation string){ +cactivation := C.CString(activation) +activationLen := len(activation) +cactivationLen := *(*C.int)(unsafe.Pointer(&activationLen)) + C.atg__sparse_semi_structured_linear(ptr, input, weight, meta, bias, cactivation, cactivationLen) +} func Atg_SparseSoftmax(ptr *Ctensor, self Ctensor, dim int64, halfToFloat int32){ cdim := *(*C.int64_t)(unsafe.Pointer(&dim)) chalfToFloat := *(*C.int)(unsafe.Pointer(&halfToFloat)) @@ -1861,6 +1931,12 @@ func Atg_TestAutogradMultipleDispatchViewCopyOut(ptr *Ctensor, out Ctensor, self func Atg_TestCheckTensor(ptr *Ctensor, self Ctensor){ C.atg__test_check_tensor(ptr, self) } +func Atg_TestFunctorchFallback(ptr *Ctensor, self Ctensor, other Ctensor){ + C.atg__test_functorch_fallback(ptr, self, other) +} +func Atg_TestFunctorchFallbackOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){ + C.atg__test_functorch_fallback_out(ptr, out, self, other) +} func Atg_TestOptionalFilledIntlist(ptr *Ctensor, values Ctensor, addendsData []int64, addendsLen int){ caddendsDataPtr := (*C.int64_t)(unsafe.Pointer(&addendsData[0])) caddendsLen := *(*C.int)(unsafe.Pointer(&addendsLen)) @@ -1920,13 +1996,90 @@ cnonBlocking := *(*C.int)(unsafe.Pointer(&nonBlocking)) C.atg__to_copy_out(ptr, out, self, cnonBlocking) } -func Atg_ToDense(ptr *Ctensor, self Ctensor, dtype int32){ -cdtype := *(*C.int)(unsafe.Pointer(&dtype)) - C.atg__to_dense(ptr, self, cdtype) +func Atg_ToDense(ptr *Ctensor, self Ctensor, dtype int32, maskedGrad int32){ +cdtype := *(*C.int)(unsafe.Pointer(&dtype)) +cmaskedGrad := *(*C.int)(unsafe.Pointer(&maskedGrad)) + C.atg__to_dense(ptr, self, cdtype, cmaskedGrad) } -func Atg_ToDenseOut(ptr *Ctensor, out Ctensor, self Ctensor, dtype int32){ -cdtype := *(*C.int)(unsafe.Pointer(&dtype)) - C.atg__to_dense_out(ptr, out, self, cdtype) +func Atg_ToDenseOut(ptr *Ctensor, out Ctensor, self Ctensor, dtype int32, maskedGrad int32){ +cdtype := *(*C.int)(unsafe.Pointer(&dtype)) +cmaskedGrad := *(*C.int)(unsafe.Pointer(&maskedGrad)) + C.atg__to_dense_out(ptr, out, self, cdtype, cmaskedGrad) +} +func Atg_ToSparse(ptr *Ctensor, self Ctensor, layout int8, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ +clayout := *(*C.int8_t)(unsafe.Pointer(&layout)) +cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) +cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse(ptr, self, clayout, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseBsc(ptr *Ctensor, self Ctensor, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ +cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) +cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_bsc(ptr, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseBscOut(ptr *Ctensor, out Ctensor, self Ctensor, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ +cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) +cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_bsc_out(ptr, out, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseBsr(ptr *Ctensor, self Ctensor, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ +cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) +cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_bsr(ptr, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseBsrOut(ptr *Ctensor, out Ctensor, self Ctensor, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ +cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) +cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_bsr_out(ptr, out, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseCsc(ptr *Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_csc(ptr, self, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseCscOut(ptr *Ctensor, out Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_csc_out(ptr, out, self, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseCsr(ptr *Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_csr(ptr, self, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseCsrOut(ptr *Ctensor, out Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_csr_out(ptr, out, self, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseOut(ptr *Ctensor, out Ctensor, self Ctensor, layout int8, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ +clayout := *(*C.int8_t)(unsafe.Pointer(&layout)) +cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) +cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) +cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) +cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) + C.atg__to_sparse_out(ptr, out, self, clayout, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) +} +func Atg_ToSparseSemiStructured(ptr *Ctensor, dense Ctensor){ + C.atg__to_sparse_semi_structured(ptr, dense) +} +func Atg_ToSparseSparseDim(ptr *Ctensor, self Ctensor, sparseDim int64){ +csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) + C.atg__to_sparse_sparse_dim(ptr, self, csparseDim) +} +func Atg_ToSparseSparseDimOut(ptr *Ctensor, out Ctensor, self Ctensor, sparseDim int64){ +csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) + C.atg__to_sparse_sparse_dim_out(ptr, out, self, csparseDim) } func Atg_TransformBiasRescaleQkv(ptr *Ctensor, qkv Ctensor, qkvBias Ctensor, numHeads int64){ cnumHeads := *(*C.int64_t)(unsafe.Pointer(&numHeads)) @@ -1936,22 +2089,6 @@ func Atg_TransformBiasRescaleQkvOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, ou cnumHeads := *(*C.int64_t)(unsafe.Pointer(&numHeads)) C.atg__transform_bias_rescale_qkv_out(ptr, out0, out1, out2, qkv, qkvBias, cnumHeads) } -func Atg_TransformerDecoderOnlyLayerFwd(ptr *Ctensor, src Ctensor, embedDim int64, numHeads int64, qkvWeight Ctensor, qkvBias Ctensor, projWeight Ctensor, projBias Ctensor, useGelu int32, normFirst int32, eps float64, normWeight1 Ctensor, normBias1 Ctensor, normWeight2 Ctensor, normBias2 Ctensor, ffnWeight1 Ctensor, ffnBias1 Ctensor, ffnWeight2 Ctensor, ffnBias2 Ctensor, mask Ctensor, incrKey Ctensor, incrValue Ctensor){ -cembedDim := *(*C.int64_t)(unsafe.Pointer(&embedDim)) -cnumHeads := *(*C.int64_t)(unsafe.Pointer(&numHeads)) -cuseGelu := *(*C.int)(unsafe.Pointer(&useGelu)) -cnormFirst := *(*C.int)(unsafe.Pointer(&normFirst)) -ceps := *(*C.double)(unsafe.Pointer(&eps)) - C.atg__transformer_decoder_only_layer_fwd(ptr, src, cembedDim, cnumHeads, qkvWeight, qkvBias, projWeight, projBias, cuseGelu, cnormFirst, ceps, normWeight1, normBias1, normWeight2, normBias2, ffnWeight1, ffnBias1, ffnWeight2, ffnBias2, mask, incrKey, incrValue) -} -func Atg_TransformerDecoderOnlyLayerFwdOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, out2 Ctensor, src Ctensor, embedDim int64, numHeads int64, qkvWeight Ctensor, qkvBias Ctensor, projWeight Ctensor, projBias Ctensor, useGelu int32, normFirst int32, eps float64, normWeight1 Ctensor, normBias1 Ctensor, normWeight2 Ctensor, normBias2 Ctensor, ffnWeight1 Ctensor, ffnBias1 Ctensor, ffnWeight2 Ctensor, ffnBias2 Ctensor, mask Ctensor, incrKey Ctensor, incrValue Ctensor){ -cembedDim := *(*C.int64_t)(unsafe.Pointer(&embedDim)) -cnumHeads := *(*C.int64_t)(unsafe.Pointer(&numHeads)) -cuseGelu := *(*C.int)(unsafe.Pointer(&useGelu)) -cnormFirst := *(*C.int)(unsafe.Pointer(&normFirst)) -ceps := *(*C.double)(unsafe.Pointer(&eps)) - C.atg__transformer_decoder_only_layer_fwd_out(ptr, out0, out1, out2, src, cembedDim, cnumHeads, qkvWeight, qkvBias, projWeight, projBias, cuseGelu, cnormFirst, ceps, normWeight1, normBias1, normWeight2, normBias2, ffnWeight1, ffnBias1, ffnWeight2, ffnBias2, mask, incrKey, incrValue) -} func Atg_TransformerEncoderLayerFwd(ptr *Ctensor, src Ctensor, embedDim int64, numHeads int64, qkvWeight Ctensor, qkvBias Ctensor, projWeight Ctensor, projBias Ctensor, useGelu int32, normFirst int32, eps float64, normWeight1 Ctensor, normBias1 Ctensor, normWeight2 Ctensor, normBias2 Ctensor, ffnWeight1 Ctensor, ffnBias1 Ctensor, ffnWeight2 Ctensor, ffnBias2 Ctensor, mask Ctensor, maskTypeVal int64, maskTypeNull int){ cembedDim := *(*C.int64_t)(unsafe.Pointer(&embedDim)) cnumHeads := *(*C.int64_t)(unsafe.Pointer(&numHeads)) @@ -2040,6 +2177,17 @@ func Atg_UnpackDual(ptr *Ctensor, dual Ctensor, level int64){ clevel := *(*C.int64_t)(unsafe.Pointer(&level)) C.atg__unpack_dual(ptr, dual, clevel) } +func Atg_UnsafeIndex(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int){ +cindicesDataPtr := (*Ctensor)(unsafe.Pointer(&indicesData[0])) +cindicesLen := *(*C.int)(unsafe.Pointer(&indicesLen)) + C.atg__unsafe_index(ptr, self, cindicesDataPtr, cindicesLen) +} +func Atg_UnsafeIndexPut(ptr *Ctensor, self Ctensor, indicesData []Ctensor, indicesLen int, values Ctensor, accumulate int32){ +cindicesDataPtr := (*Ctensor)(unsafe.Pointer(&indicesData[0])) +cindicesLen := *(*C.int)(unsafe.Pointer(&indicesLen)) +caccumulate := *(*C.int)(unsafe.Pointer(&accumulate)) + C.atg__unsafe_index_put(ptr, self, cindicesDataPtr, cindicesLen, values, caccumulate) +} func Atg_UnsafeView(ptr *Ctensor, self Ctensor, sizeData []int64, sizeLen int){ csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) @@ -3042,11 +3190,11 @@ ceps := *(*C.double)(unsafe.Pointer(&eps)) ccudnnEnabled := *(*C.int)(unsafe.Pointer(&cudnnEnabled)) C.atg_batch_norm(ptr, input, weight, bias, runningMean, runningVar, ctraining, cmomentum, ceps, ccudnnEnabled) } -func AtgBatchNormBackwardElemt(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, meanDy Ctensor, meanDyXmu Ctensor, count Ctensor){ - C.atg_batch_norm_backward_elemt(ptr, gradOut, input, mean, invstd, weight, meanDy, meanDyXmu, count) +func AtgBatchNormBackwardElemt(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, sumDy Ctensor, sumDyXmu Ctensor, count Ctensor){ + C.atg_batch_norm_backward_elemt(ptr, gradOut, input, mean, invstd, weight, sumDy, sumDyXmu, count) } -func AtgBatchNormBackwardElemtOut(ptr *Ctensor, out Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, meanDy Ctensor, meanDyXmu Ctensor, count Ctensor){ - C.atg_batch_norm_backward_elemt_out(ptr, out, gradOut, input, mean, invstd, weight, meanDy, meanDyXmu, count) +func AtgBatchNormBackwardElemtOut(ptr *Ctensor, out Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, sumDy Ctensor, sumDyXmu Ctensor, count Ctensor){ + C.atg_batch_norm_backward_elemt_out(ptr, out, gradOut, input, mean, invstd, weight, sumDy, sumDyXmu, count) } func AtgBatchNormBackwardReduce(ptr *Ctensor, gradOut Ctensor, input Ctensor, mean Ctensor, invstd Ctensor, weight Ctensor, inputG int32, weightG int32, biasG int32){ cinputG := *(*C.int)(unsafe.Pointer(&inputG)) @@ -4579,6 +4727,22 @@ csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) C.atg_empty_out(ptr, out, csizeDataPtr, csizeLen) } +func AtgEmptyPermuted(ptr *Ctensor, sizeData []int64, sizeLen int, physicalLayoutData []int64, physicalLayoutLen int, optionsKind int32, optionsDevice int32){ +csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) +csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) +cphysicalLayoutDataPtr := (*C.int64_t)(unsafe.Pointer(&physicalLayoutData[0])) +cphysicalLayoutLen := *(*C.int)(unsafe.Pointer(&physicalLayoutLen)) +coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) +coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) + C.atg_empty_permuted(ptr, csizeDataPtr, csizeLen, cphysicalLayoutDataPtr, cphysicalLayoutLen, coptionsKind, coptionsDevice) +} +func AtgEmptyPermutedOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int, physicalLayoutData []int64, physicalLayoutLen int){ +csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) +csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) +cphysicalLayoutDataPtr := (*C.int64_t)(unsafe.Pointer(&physicalLayoutData[0])) +cphysicalLayoutLen := *(*C.int)(unsafe.Pointer(&physicalLayoutLen)) + C.atg_empty_permuted_out(ptr, out, csizeDataPtr, csizeLen, cphysicalLayoutDataPtr, cphysicalLayoutLen) +} func AtgEmptyQuantized(ptr *Ctensor, sizeData []int64, sizeLen int, qtensor Ctensor, optionsKind int32, optionsDevice int32){ csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) @@ -7544,6 +7708,9 @@ func AtgMinOther(ptr *Ctensor, self Ctensor, other Ctensor){ func AtgMinOut(ptr *Ctensor, out Ctensor, self Ctensor, other Ctensor){ C.atg_min_out(ptr, out, self, other) } +func AtgMinUnaryOut(ptr *Ctensor, out Ctensor, self Ctensor){ + C.atg_min_unary_out(ptr, out, self) +} func AtgMinimum(ptr *Ctensor, self Ctensor, other Ctensor){ C.atg_minimum(ptr, self, other) } @@ -8491,6 +8658,16 @@ func AtgNonzero(ptr *Ctensor, self Ctensor){ func AtgNonzeroOut(ptr *Ctensor, out Ctensor, self Ctensor){ C.atg_nonzero_out(ptr, out, self) } +func AtgNonzeroStatic(ptr *Ctensor, self Ctensor, size int64, fillValue int64){ +csize := *(*C.int64_t)(unsafe.Pointer(&size)) +cfillValue := *(*C.int64_t)(unsafe.Pointer(&fillValue)) + C.atg_nonzero_static(ptr, self, csize, cfillValue) +} +func AtgNonzeroStaticOut(ptr *Ctensor, out Ctensor, self Ctensor, size int64, fillValue int64){ +csize := *(*C.int64_t)(unsafe.Pointer(&size)) +cfillValue := *(*C.int64_t)(unsafe.Pointer(&fillValue)) + C.atg_nonzero_static_out(ptr, out, self, csize, cfillValue) +} func AtgNorm(ptr *Ctensor, self Ctensor){ C.atg_norm(ptr, self) } @@ -8963,6 +9140,30 @@ cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen)) cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode)) C.atg_quantized_max_pool2d_out(ptr, out, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode) } +func AtgQuantizedMaxPool3d(ptr *Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){ +ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0])) +ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen)) +cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0])) +cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen)) +cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0])) +cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen)) +cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0])) +cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen)) +cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode)) + C.atg_quantized_max_pool3d(ptr, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode) +} +func AtgQuantizedMaxPool3dOut(ptr *Ctensor, out Ctensor, self Ctensor, kernelSizeData []int64, kernelSizeLen int, strideData []int64, strideLen int, paddingData []int64, paddingLen int, dilationData []int64, dilationLen int, ceilMode int32){ +ckernelSizeDataPtr := (*C.int64_t)(unsafe.Pointer(&kernelSizeData[0])) +ckernelSizeLen := *(*C.int)(unsafe.Pointer(&kernelSizeLen)) +cstrideDataPtr := (*C.int64_t)(unsafe.Pointer(&strideData[0])) +cstrideLen := *(*C.int)(unsafe.Pointer(&strideLen)) +cpaddingDataPtr := (*C.int64_t)(unsafe.Pointer(&paddingData[0])) +cpaddingLen := *(*C.int)(unsafe.Pointer(&paddingLen)) +cdilationDataPtr := (*C.int64_t)(unsafe.Pointer(&dilationData[0])) +cdilationLen := *(*C.int)(unsafe.Pointer(&dilationLen)) +cceilMode := *(*C.int)(unsafe.Pointer(&ceilMode)) + C.atg_quantized_max_pool3d_out(ptr, out, self, ckernelSizeDataPtr, ckernelSizeLen, cstrideDataPtr, cstrideLen, cpaddingDataPtr, cpaddingLen, cdilationDataPtr, cdilationLen, cceilMode) +} func AtgQuantizedRnnReluCell(ptr *Ctensor, input Ctensor, hx Ctensor, wIh Ctensor, wHh Ctensor, bIh Ctensor, bHh Ctensor, packedIh Ctensor, packedHh Ctensor, colOffsetsIh Ctensor, colOffsetsHh Ctensor, scaleIh Cscalar, scaleHh Cscalar, zeroPointIh Cscalar, zeroPointHh Cscalar){ C.atg_quantized_rnn_relu_cell(ptr, input, hx, wIh, wHh, bIh, bHh, packedIh, packedHh, colOffsetsIh, colOffsetsHh, scaleIh , scaleHh , zeroPointIh , zeroPointHh ) } @@ -9578,10 +9779,12 @@ coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) func AtgScalarTensorOut(ptr *Ctensor, out Ctensor, s Cscalar){ C.atg_scalar_tensor_out(ptr, out, s ) } -func AtgScaledDotProductAttention(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, attnMask Ctensor, dropoutP float64, isCausal int32){ +func AtgScaledDotProductAttention(ptr *Ctensor, query Ctensor, key Ctensor, value Ctensor, attnMask Ctensor, dropoutP float64, isCausal int32, scaleVal float64, scaleNull int){ cdropoutP := *(*C.double)(unsafe.Pointer(&dropoutP)) -cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) - C.atg_scaled_dot_product_attention(ptr, query, key, value, attnMask, cdropoutP, cisCausal) +cisCausal := *(*C.int)(unsafe.Pointer(&isCausal)) +cscaleVal := *(*C.double)(unsafe.Pointer(&scaleVal)) +cscaleNull := *(*C.uint8_t)(unsafe.Pointer(&scaleNull)) + C.atg_scaled_dot_product_attention(ptr, query, key, value, attnMask, cdropoutP, cisCausal, cscaleVal, cscaleNull) } func AtgScatter(ptr *Ctensor, self Ctensor, dim int64, index Ctensor, src Ctensor){ cdim := *(*C.int64_t)(unsafe.Pointer(&dim)) @@ -10186,17 +10389,19 @@ coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) C.atg_sparse_coo_tensor(ptr, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice) } -func AtgSparseCooTensorIndices(ptr *Ctensor, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32){ +func AtgSparseCooTensorIndices(ptr *Ctensor, indices Ctensor, values Ctensor, optionsKind int32, optionsDevice int32, isCoalesced int32){ coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) -coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) - C.atg_sparse_coo_tensor_indices(ptr, indices, values, coptionsKind, coptionsDevice) +coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) +cisCoalesced := *(*C.int)(unsafe.Pointer(&isCoalesced)) + C.atg_sparse_coo_tensor_indices(ptr, indices, values, coptionsKind, coptionsDevice, cisCoalesced) } -func AtgSparseCooTensorIndicesSize(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32){ +func AtgSparseCooTensorIndicesSize(ptr *Ctensor, indices Ctensor, values Ctensor, sizeData []int64, sizeLen int, optionsKind int32, optionsDevice int32, isCoalesced int32){ csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) csizeLen := *(*C.int)(unsafe.Pointer(&sizeLen)) coptionsKind := *(*C.int)(unsafe.Pointer(&optionsKind)) -coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) - C.atg_sparse_coo_tensor_indices_size(ptr, indices, values, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice) +coptionsDevice := *(*C.int)(unsafe.Pointer(&optionsDevice)) +cisCoalesced := *(*C.int)(unsafe.Pointer(&isCoalesced)) + C.atg_sparse_coo_tensor_indices_size(ptr, indices, values, csizeDataPtr, csizeLen, coptionsKind, coptionsDevice, cisCoalesced) } func AtgSparseCooTensorSizeOut(ptr *Ctensor, out Ctensor, sizeData []int64, sizeLen int){ csizeDataPtr := (*C.int64_t)(unsafe.Pointer(&sizeData[0])) @@ -10908,21 +11113,17 @@ func AtgStd(ptr *Ctensor, self Ctensor, unbiased int32){ cunbiased := *(*C.int)(unsafe.Pointer(&unbiased)) C.atg_std(ptr, self, cunbiased) } -func AtgStdCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgStdCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_std_correction(ptr, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_std_correction(ptr, self, cdimDataPtr, cdimLen, correction , ckeepdim) } -func AtgStdCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgStdCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_std_correction_out(ptr, out, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_std_correction_out(ptr, out, self, cdimDataPtr, cdimLen, correction , ckeepdim) } func AtgStdDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) @@ -10935,21 +11136,17 @@ func AtgStdMean(ptr *Ctensor, self Ctensor, unbiased int32){ cunbiased := *(*C.int)(unsafe.Pointer(&unbiased)) C.atg_std_mean(ptr, self, cunbiased) } -func AtgStdMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgStdMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_std_mean_correction(ptr, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_std_mean_correction(ptr, self, cdimDataPtr, cdimLen, correction , ckeepdim) } -func AtgStdMeanCorrectionOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgStdMeanCorrectionOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_std_mean_correction_out(ptr, out0, out1, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_std_mean_correction_out(ptr, out0, out1, self, cdimDataPtr, cdimLen, correction , ckeepdim) } func AtgStdMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) @@ -11081,6 +11278,8 @@ cdim0 := *(*C.int64_t)(unsafe.Pointer(&dim0)) cdim1 := *(*C.int64_t)(unsafe.Pointer(&dim1)) C.atg_swapdims_(ptr, self, cdim0, cdim1) } + + func AtgT(ptr *Ctensor, self Ctensor){ C.atg_t(ptr, self) } @@ -11174,12 +11373,14 @@ func AtgTo(ptr *Ctensor, self Ctensor, device int32){ cdevice := *(*C.int)(unsafe.Pointer(&device)) C.atg_to(ptr, self, cdevice) } -func AtgToDense(ptr *Ctensor, self Ctensor, dtype int32){ -cdtype := *(*C.int)(unsafe.Pointer(&dtype)) - C.atg_to_dense(ptr, self, cdtype) +func AtgToDense(ptr *Ctensor, self Ctensor, dtype int32, maskedGrad int32){ +cdtype := *(*C.int)(unsafe.Pointer(&dtype)) +cmaskedGrad := *(*C.int)(unsafe.Pointer(&maskedGrad)) + C.atg_to_dense(ptr, self, cdtype, cmaskedGrad) } -func AtgToDenseBackward(ptr *Ctensor, grad Ctensor, input Ctensor){ - C.atg_to_dense_backward(ptr, grad, input) +func AtgToDenseBackward(ptr *Ctensor, grad Ctensor, input Ctensor, maskedGrad int32){ +cmaskedGrad := *(*C.int)(unsafe.Pointer(&maskedGrad)) + C.atg_to_dense_backward(ptr, grad, input, cmaskedGrad) } func AtgToDevice(ptr *Ctensor, self Ctensor, device int32, dtype int32, nonBlocking int32, copy int32){ cdevice := *(*C.int)(unsafe.Pointer(&device)) @@ -11244,13 +11445,6 @@ cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) C.atg_to_sparse_bsc(ptr, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) } -func AtgToSparseBscOut(ptr *Ctensor, out Ctensor, self Ctensor, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ -cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) -cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) -cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) -cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) - C.atg_to_sparse_bsc_out(ptr, out, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) -} func AtgToSparseBsr(ptr *Ctensor, self Ctensor, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) @@ -11258,49 +11452,20 @@ cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) C.atg_to_sparse_bsr(ptr, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) } -func AtgToSparseBsrOut(ptr *Ctensor, out Ctensor, self Ctensor, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ -cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) -cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) -cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) -cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) - C.atg_to_sparse_bsr_out(ptr, out, self, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) -} func AtgToSparseCsc(ptr *Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) C.atg_to_sparse_csc(ptr, self, cdenseDimVal, cdenseDimNull) } -func AtgToSparseCscOut(ptr *Ctensor, out Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ -cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) -cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) - C.atg_to_sparse_csc_out(ptr, out, self, cdenseDimVal, cdenseDimNull) -} func AtgToSparseCsr(ptr *Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) C.atg_to_sparse_csr(ptr, self, cdenseDimVal, cdenseDimNull) } -func AtgToSparseCsrOut(ptr *Ctensor, out Ctensor, self Ctensor, denseDimVal int64, denseDimNull int){ -cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) -cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) - C.atg_to_sparse_csr_out(ptr, out, self, cdenseDimVal, cdenseDimNull) -} -func AtgToSparseOut(ptr *Ctensor, out Ctensor, self Ctensor, layout int8, blocksizeData []int64, blocksizeLen int, denseDimVal int64, denseDimNull int){ -clayout := *(*C.int8_t)(unsafe.Pointer(&layout)) -cblocksizeDataPtr := (*C.int64_t)(unsafe.Pointer(&blocksizeData[0])) -cblocksizeLen := *(*C.int)(unsafe.Pointer(&blocksizeLen)) -cdenseDimVal := *(*C.int64_t)(unsafe.Pointer(&denseDimVal)) -cdenseDimNull := *(*C.uint8_t)(unsafe.Pointer(&denseDimNull)) - C.atg_to_sparse_out(ptr, out, self, clayout, cblocksizeDataPtr, cblocksizeLen, cdenseDimVal, cdenseDimNull) -} func AtgToSparseSparseDim(ptr *Ctensor, self Ctensor, sparseDim int64){ csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) C.atg_to_sparse_sparse_dim(ptr, self, csparseDim) } -func AtgToSparseSparseDimOut(ptr *Ctensor, out Ctensor, self Ctensor, sparseDim int64){ -csparseDim := *(*C.int64_t)(unsafe.Pointer(&sparseDim)) - C.atg_to_sparse_sparse_dim_out(ptr, out, self, csparseDim) -} func AtgTopk(ptr *Ctensor, self Ctensor, k int64, dim int64, largest int32, sorted int32){ ck := *(*C.int64_t)(unsafe.Pointer(&k)) cdim := *(*C.int64_t)(unsafe.Pointer(&dim)) @@ -11958,21 +12123,17 @@ func AtgVar(ptr *Ctensor, self Ctensor, unbiased int32){ cunbiased := *(*C.int)(unsafe.Pointer(&unbiased)) C.atg_var(ptr, self, cunbiased) } -func AtgVarCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgVarCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_var_correction(ptr, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_var_correction(ptr, self, cdimDataPtr, cdimLen, correction , ckeepdim) } -func AtgVarCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgVarCorrectionOut(ptr *Ctensor, out Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_var_correction_out(ptr, out, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_var_correction_out(ptr, out, self, cdimDataPtr, cdimLen, correction , ckeepdim) } func AtgVarDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) @@ -11985,21 +12146,17 @@ func AtgVarMean(ptr *Ctensor, self Ctensor, unbiased int32){ cunbiased := *(*C.int)(unsafe.Pointer(&unbiased)) C.atg_var_mean(ptr, self, cunbiased) } -func AtgVarMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgVarMeanCorrection(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_var_mean_correction(ptr, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_var_mean_correction(ptr, self, cdimDataPtr, cdimLen, correction , ckeepdim) } -func AtgVarMeanCorrectionOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, self Ctensor, dimData []int64, dimLen int, correctionVal int64, correctionNull int, keepdim int32){ +func AtgVarMeanCorrectionOut(ptr *Ctensor, out0 Ctensor, out1 Ctensor, self Ctensor, dimData []int64, dimLen int, correction Cscalar, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) cdimLen := *(*C.int)(unsafe.Pointer(&dimLen)) -ccorrectionVal := *(*C.int64_t)(unsafe.Pointer(&correctionVal)) -ccorrectionNull := *(*C.uint8_t)(unsafe.Pointer(&correctionNull)) ckeepdim := *(*C.int)(unsafe.Pointer(&keepdim)) - C.atg_var_mean_correction_out(ptr, out0, out1, self, cdimDataPtr, cdimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + C.atg_var_mean_correction_out(ptr, out0, out1, self, cdimDataPtr, cdimLen, correction , ckeepdim) } func AtgVarMeanDim(ptr *Ctensor, self Ctensor, dimData []int64, dimLen int, unbiased int32, keepdim int32){ cdimDataPtr := (*C.int64_t)(unsafe.Pointer(&dimData[0])) diff --git a/libtch/lib.go b/libtch/lib.go index da99f88..4f22530 100644 --- a/libtch/lib.go +++ b/libtch/lib.go @@ -5,6 +5,6 @@ package libtch // #cgo CFLAGS: -I${SRCDIR} -O3 -Wall -Wno-unused-variable -Wno-deprecated-declarations -Wno-c++11-narrowing -g -Wno-sign-compare -Wno-unused-function // #cgo CFLAGS: -D_GLIBCXX_USE_CXX11_ABI=0 // #cgo CFLAGS: -I/usr/local/cuda/include -// #cgo CXXFLAGS: -std=c++14 -I${SRCDIR} -g -O3 +// #cgo CXXFLAGS: -std=c++17 -I${SRCDIR} -g -O3 // #cgo CXXFLAGS: -I${SRCDIR}/libtorch/lib -I${SRCDIR}/libtorch/include -I${SRCDIR}/libtorch/include/torch/csrc/api/include import "C" diff --git a/libtch/torch_api_generated.cpp.h b/libtch/torch_api_generated.cpp.h index f79121f..f74a993 100644 --- a/libtch/torch_api_generated.cpp.h +++ b/libtch/torch_api_generated.cpp.h @@ -439,13 +439,6 @@ void atg__cholesky_solve_helper_out(tensor *out__, tensor out, tensor self, tens ) } -int atg__chunk_grad_outputs_efficient_attention(tensor query, tensor key, tensor value, int is_causal) { - PROTECT( - return torch::_chunk_grad_outputs_efficient_attention(*query, *key, *value, (bool)is_causal); - ) - return 0; -} - void atg__coalesce(tensor *out__, tensor self) { PROTECT( auto outputs__ = torch::_coalesce(*self); @@ -628,6 +621,20 @@ void atg__copy_from_out(tensor *out__, tensor out, tensor self, tensor dst, int ) } +void atg__cslt_compress(tensor *out__, tensor input) { + PROTECT( + auto outputs__ = torch::_cslt_compress(*input); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__cslt_sparse_mm(tensor *out__, tensor compressed_A, tensor dense_B, tensor bias, int transpose_result) { + PROTECT( + auto outputs__ = torch::_cslt_sparse_mm(*compressed_A, *dense_B, (bias ? *bias : torch::Tensor()), (bool)transpose_result); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__ctc_loss(tensor *out__, tensor log_probs, tensor targets, int64_t *input_lengths_data, int input_lengths_len, int64_t *target_lengths_data, int target_lengths_len, int64_t blank, int zero_infinity) { PROTECT( auto outputs__ = torch::_ctc_loss(*log_probs, *targets, torch::IntArrayRef(input_lengths_data, input_lengths_len), torch::IntArrayRef(target_lengths_data, target_lengths_len), blank, (bool)zero_infinity); @@ -755,20 +762,6 @@ void atg__cudnn_rnn_out(tensor *out__, tensor out0, tensor out1, tensor out2, te ) } -int64_t atg__cufft_get_plan_cache_max_size(int64_t device_index) { - PROTECT( - return torch::_cufft_get_plan_cache_max_size(device_index); - ) - return 0; -} - -int64_t atg__cufft_get_plan_cache_size(int64_t device_index) { - PROTECT( - return torch::_cufft_get_plan_cache_size(device_index); - ) - return 0; -} - int64_t atg__debug_has_internal_overlap(tensor self) { PROTECT( return torch::_debug_has_internal_overlap(*self); @@ -811,12 +804,13 @@ void atg__dirichlet_grad_out(tensor *out__, tensor out, tensor x, tensor alpha, ) } -void atg__efficient_attention_backward(tensor *out__, tensor grad_out_, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, int is_causal, int chunk_grad_outputs) { +void atg__efficient_attention_backward(tensor *out__, tensor grad_out_, tensor query, tensor key, tensor value, tensor bias, tensor out, tensor cu_seqlens_q, tensor cu_seqlens_k, int64_t max_seqlen_k, int64_t max_seqlen_q, tensor logsumexp, double dropout_p, tensor philox_seed, tensor philox_offset, int64_t custom_mask_type, int bias_requires_grad, double scale_v, uint8_t scale_null, int64_t num_splits_key_v, uint8_t num_splits_key_null) { PROTECT( - auto outputs__ = torch::_efficient_attention_backward(*grad_out_, *query, *key, *value, *out, *logsumexp, (bool)is_causal, (bool)chunk_grad_outputs); + auto outputs__ = torch::_efficient_attention_backward(*grad_out_, *query, *key, *value, (bias ? *bias : torch::Tensor()), *out, (cu_seqlens_q ? *cu_seqlens_q : torch::Tensor()), (cu_seqlens_k ? *cu_seqlens_k : torch::Tensor()), max_seqlen_k, max_seqlen_q, *logsumexp, dropout_p, *philox_seed, *philox_offset, custom_mask_type, (bool)bias_requires_grad, scale_null ? c10::nullopt : c10::optional(scale_v), num_splits_key_null ? c10::nullopt : c10::optional(num_splits_key_v)); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); out__[2] = new torch::Tensor(std::get<2>(outputs__)); + out__[3] = new torch::Tensor(std::get<3>(outputs__)); ) } @@ -1062,9 +1056,16 @@ void atg__fft_r2c_out(tensor *out__, tensor out, tensor self, int64_t *dim_data, ) } -void atg__flash_attention_backward(tensor *out__, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, int64_t philox_seed, int64_t philox_offset) { +void atg__fill_mem_eff_dropout_mask_(tensor *out__, tensor self, double dropout_p, int64_t seed, int64_t offset) { PROTECT( - auto outputs__ = torch::_flash_attention_backward(*grad_out, *query, *key, *value, *out, *logsumexp, *cum_seq_q, *cum_seq_k, max_q, max_k, dropout_p, (bool)is_causal, philox_seed, philox_offset); + auto outputs__ = torch::_fill_mem_eff_dropout_mask_(*self, dropout_p, seed, offset); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__flash_attention_backward(tensor *out__, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, tensor philox_seed, tensor philox_offset, double scale_v, uint8_t scale_null) { + PROTECT( + auto outputs__ = torch::_flash_attention_backward(*grad_out, *query, *key, *value, *out, *logsumexp, *cum_seq_q, *cum_seq_k, max_q, max_k, dropout_p, (bool)is_causal, *philox_seed, *philox_offset, scale_null ? c10::nullopt : c10::optional(scale_v)); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); out__[2] = new torch::Tensor(std::get<2>(outputs__)); @@ -1085,6 +1086,27 @@ void atg__foobar_out(tensor *out__, tensor out, tensor self, int arg1, int arg2, ) } +void atg__functional_assert_async(tensor *out__, tensor self, char* assert_msg_ptr, int assert_msg_len, tensor dep_token) { + PROTECT( + auto outputs__ = torch::_functional_assert_async(*self, std::string(assert_msg_ptr, assert_msg_len), *dep_token); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__functional_sym_constrain_range(tensor *out__, scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null, tensor dep_token) { + PROTECT( + auto outputs__ = torch::_functional_sym_constrain_range(*size, min_null ? c10::nullopt : c10::optional(min_v), max_null ? c10::nullopt : c10::optional(max_v), *dep_token); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__functional_sym_constrain_range_for_size(tensor *out__, scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null, tensor dep_token) { + PROTECT( + auto outputs__ = torch::_functional_sym_constrain_range_for_size(*size, min_null ? c10::nullopt : c10::optional(min_v), max_null ? c10::nullopt : c10::optional(max_v), *dep_token); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__fused_dropout(tensor *out__, tensor self, double p) { PROTECT( auto outputs__ = torch::_fused_dropout(*self, p); @@ -1129,9 +1151,9 @@ void atg__fused_moving_avg_obs_fq_helper_out(tensor *out__, tensor out0, tensor ) } -int64_t atg__fused_sdp_choice(tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal) { +int64_t atg__fused_sdp_choice(tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, double scale_v, uint8_t scale_null) { PROTECT( - return torch::_fused_sdp_choice(*query, *key, *value, (attn_mask ? *attn_mask : torch::Tensor()), dropout_p, (bool)is_causal); + return torch::_fused_sdp_choice(*query, *key, *value, (attn_mask ? *attn_mask : torch::Tensor()), dropout_p, (bool)is_causal, scale_null ? c10::nullopt : c10::optional(scale_v)); ) return 0; } @@ -1263,6 +1285,20 @@ void atg__indices_copy_out(tensor *out__, tensor out, tensor self) { ) } +void atg__int_mm(tensor *out__, tensor self, tensor mat2) { + PROTECT( + auto outputs__ = torch::_int_mm(*self, *mat2); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__int_mm_out(tensor *out__, tensor out, tensor self, tensor mat2) { + PROTECT( + auto outputs__ = torch::_int_mm_out(*out, *self, *mat2); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__is_all_true(tensor *out__, tensor self) { PROTECT( auto outputs__ = torch::_is_all_true(*self); @@ -1451,6 +1487,13 @@ void atg__lu_with_info(tensor *out__, tensor self, int pivot, int check_errors) ) } +void atg__make_dep_token(tensor *out__, int options_kind, int options_device) { + PROTECT( + auto outputs__ = torch::_make_dep_token(at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind))); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__make_dual(tensor *out__, tensor primal, tensor tangent, int64_t level) { PROTECT( auto outputs__ = torch::_make_dual(*primal, *tangent, level); @@ -1643,6 +1686,24 @@ void atg__native_batch_norm_legit_no_stats_out(tensor *out__, tensor out, tensor ) } +void atg__native_batch_norm_legit_no_training(tensor *out__, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, double momentum, double eps) { + PROTECT( + auto outputs__ = torch::_native_batch_norm_legit_no_training(*input, (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), *running_mean, *running_var, momentum, eps); + out__[0] = new torch::Tensor(std::get<0>(outputs__)); + out__[1] = new torch::Tensor(std::get<1>(outputs__)); + out__[2] = new torch::Tensor(std::get<2>(outputs__)); + ) +} + +void atg__native_batch_norm_legit_no_training_out(tensor *out__, tensor out0, tensor out1, tensor out2, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, double momentum, double eps) { + PROTECT( + auto outputs__ = torch::_native_batch_norm_legit_no_training_out(*out0, *out1, *out2, *input, (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), *running_mean, *running_var, momentum, eps); + out__[0] = new torch::Tensor(std::get<0>(outputs__)); + out__[1] = new torch::Tensor(std::get<1>(outputs__)); + out__[2] = new torch::Tensor(std::get<2>(outputs__)); + ) +} + void atg__native_batch_norm_legit_out(tensor *out__, tensor out, tensor save_mean, tensor save_invstd, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double momentum, double eps) { PROTECT( auto outputs__ = torch::_native_batch_norm_legit_out(*out, *save_mean, *save_invstd, *input, (weight ? *weight : torch::Tensor()), (bias ? *bias : torch::Tensor()), *running_mean, *running_var, (bool)training, momentum, eps); @@ -1652,26 +1713,6 @@ void atg__native_batch_norm_legit_out(tensor *out__, tensor out, tensor save_mea ) } -void atg__native_decoder_only_multi_head_attention(tensor *out__, tensor query, tensor key, tensor value, int64_t embed_dim, int64_t num_head, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, tensor mask, tensor incr_key, tensor incr_value, int need_weights, int average_attn_weights) { - PROTECT( - auto outputs__ = torch::_native_decoder_only_multi_head_attention(*query, *key, *value, embed_dim, num_head, *qkv_weight, *qkv_bias, *proj_weight, *proj_bias, (mask ? *mask : torch::Tensor()), (incr_key ? *incr_key : torch::Tensor()), (incr_value ? *incr_value : torch::Tensor()), (bool)need_weights, (bool)average_attn_weights); - out__[0] = new torch::Tensor(std::get<0>(outputs__)); - out__[1] = new torch::Tensor(std::get<1>(outputs__)); - out__[2] = new torch::Tensor(std::get<2>(outputs__)); - out__[3] = new torch::Tensor(std::get<3>(outputs__)); - ) -} - -void atg__native_decoder_only_multi_head_attention_out(tensor *out__, tensor out0, tensor out1, tensor out2, tensor out3, tensor query, tensor key, tensor value, int64_t embed_dim, int64_t num_head, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, tensor mask, tensor incr_key, tensor incr_value, int need_weights, int average_attn_weights) { - PROTECT( - auto outputs__ = torch::_native_decoder_only_multi_head_attention_out(*out0, *out1, *out2, *out3, *query, *key, *value, embed_dim, num_head, *qkv_weight, *qkv_bias, *proj_weight, *proj_bias, (mask ? *mask : torch::Tensor()), (incr_key ? *incr_key : torch::Tensor()), (incr_value ? *incr_value : torch::Tensor()), (bool)need_weights, (bool)average_attn_weights); - out__[0] = new torch::Tensor(std::get<0>(outputs__)); - out__[1] = new torch::Tensor(std::get<1>(outputs__)); - out__[2] = new torch::Tensor(std::get<2>(outputs__)); - out__[3] = new torch::Tensor(std::get<3>(outputs__)); - ) -} - void atg__native_multi_head_attention(tensor *out__, tensor query, tensor key, tensor value, int64_t embed_dim, int64_t num_head, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, tensor mask, int need_weights, int average_attn_weights, int64_t mask_type_v, uint8_t mask_type_null) { PROTECT( auto outputs__ = torch::_native_multi_head_attention(*query, *key, *value, embed_dim, num_head, *qkv_weight, *qkv_bias, *proj_weight, *proj_bias, (mask ? *mask : torch::Tensor()), (bool)need_weights, (bool)average_attn_weights, mask_type_null ? c10::nullopt : c10::optional(mask_type_v)); @@ -1751,23 +1792,23 @@ void atg__nested_sum_backward(tensor *out__, tensor grad, tensor self, int64_t * ) } -void atg__nested_view_from_buffer(tensor *out__, tensor self, tensor nested_size, tensor nested_strides, int64_t *offsets_data, int offsets_len) { +void atg__nested_view_from_buffer(tensor *out__, tensor self, tensor nested_size, tensor nested_strides, tensor offsets) { PROTECT( - auto outputs__ = torch::_nested_view_from_buffer(*self, *nested_size, *nested_strides, torch::IntArrayRef(offsets_data, offsets_len)); + auto outputs__ = torch::_nested_view_from_buffer(*self, *nested_size, *nested_strides, *offsets); out__[0] = new torch::Tensor(outputs__); ) } -void atg__nested_view_from_buffer_copy(tensor *out__, tensor self, tensor nested_size, tensor nested_strides, int64_t *offsets_data, int offsets_len) { +void atg__nested_view_from_buffer_copy(tensor *out__, tensor self, tensor nested_size, tensor nested_strides, tensor offsets) { PROTECT( - auto outputs__ = torch::_nested_view_from_buffer_copy(*self, *nested_size, *nested_strides, torch::IntArrayRef(offsets_data, offsets_len)); + auto outputs__ = torch::_nested_view_from_buffer_copy(*self, *nested_size, *nested_strides, *offsets); out__[0] = new torch::Tensor(outputs__); ) } -void atg__nested_view_from_buffer_copy_out(tensor *out__, tensor out, tensor self, tensor nested_size, tensor nested_strides, int64_t *offsets_data, int offsets_len) { +void atg__nested_view_from_buffer_copy_out(tensor *out__, tensor out, tensor self, tensor nested_size, tensor nested_strides, tensor offsets) { PROTECT( - auto outputs__ = torch::_nested_view_from_buffer_copy_out(*out, *self, *nested_size, *nested_strides, torch::IntArrayRef(offsets_data, offsets_len)); + auto outputs__ = torch::_nested_view_from_buffer_copy_out(*out, *self, *nested_size, *nested_strides, *offsets); out__[0] = new torch::Tensor(outputs__); ) } @@ -1902,6 +1943,12 @@ void atg__prelu_kernel_backward(tensor *out__, tensor grad_output, tensor self, ) } +void atg__propagate_xla_data(tensor input, tensor output) { + PROTECT( + torch::_propagate_xla_data(*input, *output); + ) +} + void atg__remove_batch_dim(tensor *out__, tensor self, int64_t level, int64_t batch_size, int64_t out_dim) { PROTECT( auto outputs__ = torch::_remove_batch_dim(*self, level, batch_size, out_dim); @@ -1994,45 +2041,67 @@ void atg__saturate_weight_to_fp16(tensor *out__, tensor weight) { ) } -void atg__scaled_dot_product_attention(tensor *out__, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int need_attn_weights, int is_causal) { +void atg__scaled_dot_product_attention_math(tensor *out__, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, tensor dropout_mask, double scale_v, uint8_t scale_null) { PROTECT( - auto outputs__ = torch::_scaled_dot_product_attention(*query, *key, *value, (attn_mask ? *attn_mask : torch::Tensor()), dropout_p, (bool)need_attn_weights, (bool)is_causal); + auto outputs__ = torch::_scaled_dot_product_attention_math(*query, *key, *value, (attn_mask ? *attn_mask : torch::Tensor()), dropout_p, (bool)is_causal, (dropout_mask ? *dropout_mask : torch::Tensor()), scale_null ? c10::nullopt : c10::optional(scale_v)); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); ) } -void atg__scaled_dot_product_attention_math(tensor *out__, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, tensor dropout_mask) { +void atg__scaled_dot_product_efficient_attention(tensor *out__, tensor query, tensor key, tensor value, tensor attn_bias, int compute_log_sumexp, double dropout_p, int is_causal, double scale_v, uint8_t scale_null) { PROTECT( - auto outputs__ = torch::_scaled_dot_product_attention_math(*query, *key, *value, (attn_mask ? *attn_mask : torch::Tensor()), dropout_p, (bool)is_causal, (dropout_mask ? *dropout_mask : torch::Tensor())); + auto outputs__ = torch::_scaled_dot_product_efficient_attention(*query, *key, *value, (attn_bias ? *attn_bias : torch::Tensor()), (bool)compute_log_sumexp, dropout_p, (bool)is_causal, scale_null ? c10::nullopt : c10::optional(scale_v)); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); + out__[2] = new torch::Tensor(std::get<2>(outputs__)); + out__[3] = new torch::Tensor(std::get<3>(outputs__)); ) } -void atg__scaled_dot_product_efficient_attention(tensor *out__, tensor query, tensor key, tensor value, int compute_log_sumexp, int is_causal) { +void atg__scaled_dot_product_flash_attention_backward(tensor *out__, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, tensor philox_seed, tensor philox_offset, double scale_v, uint8_t scale_null) { PROTECT( - auto outputs__ = torch::_scaled_dot_product_efficient_attention(*query, *key, *value, (bool)compute_log_sumexp, (bool)is_causal); - out__[0] = new torch::Tensor(std::get<0>(outputs__)); - out__[1] = new torch::Tensor(std::get<1>(outputs__)); - ) -} - -void atg__scaled_dot_product_efficient_attention_backward(tensor *out__, tensor grad_out_, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, int is_causal, int chunk_grad_outputs) { - PROTECT( - auto outputs__ = torch::_scaled_dot_product_efficient_attention_backward(*grad_out_, *query, *key, *value, *out, *logsumexp, (bool)is_causal, (bool)chunk_grad_outputs); + auto outputs__ = torch::_scaled_dot_product_flash_attention_backward(*grad_out, *query, *key, *value, *out, *logsumexp, *cum_seq_q, *cum_seq_k, max_q, max_k, dropout_p, (bool)is_causal, *philox_seed, *philox_offset, scale_null ? c10::nullopt : c10::optional(scale_v)); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); out__[2] = new torch::Tensor(std::get<2>(outputs__)); ) } -void atg__scaled_dot_product_flash_attention_backward(tensor *out__, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, int64_t philox_seed, int64_t philox_offset) { +void atg__scaled_mm(tensor *out__, tensor self, tensor mat2, tensor bias, int out_dtype, tensor scale_a, tensor scale_b, tensor scale_result) { PROTECT( - auto outputs__ = torch::_scaled_dot_product_flash_attention_backward(*grad_out, *query, *key, *value, *out, *logsumexp, *cum_seq_q, *cum_seq_k, max_q, max_k, dropout_p, (bool)is_causal, philox_seed, philox_offset); + auto outputs__ = torch::_scaled_mm(*self, *mat2, (bias ? *bias : torch::Tensor()), out_dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(out_dtype)), (scale_a ? *scale_a : torch::Tensor()), (scale_b ? *scale_b : torch::Tensor()), (scale_result ? *scale_result : torch::Tensor())); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); - out__[2] = new torch::Tensor(std::get<2>(outputs__)); + ) +} + +void atg__scaled_mm_out(tensor *out__, tensor out, tensor out_amax, tensor self, tensor mat2, tensor bias, int out_dtype, tensor scale_a, tensor scale_b, tensor scale_result) { + PROTECT( + auto outputs__ = torch::_scaled_mm_out(*out, *out_amax, *self, *mat2, (bias ? *bias : torch::Tensor()), out_dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(out_dtype)), (scale_a ? *scale_a : torch::Tensor()), (scale_b ? *scale_b : torch::Tensor()), (scale_result ? *scale_result : torch::Tensor())); + out__[0] = new torch::Tensor(std::get<0>(outputs__)); + out__[1] = new torch::Tensor(std::get<1>(outputs__)); + ) +} + +void atg__scatter_reduce(tensor *out__, tensor self, int64_t dim, tensor index, tensor src, char* reduce_ptr, int reduce_len, int include_self) { + PROTECT( + auto outputs__ = torch::scatter_reduce(*self, dim, *index, *src, std::string(reduce_ptr, reduce_len), (bool)include_self); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__scatter_reduce_(tensor *out__, tensor self, int64_t dim, tensor index, tensor src, char* reduce_ptr, int reduce_len, int include_self) { + PROTECT( + auto outputs__ = self->scatter_reduce_(dim, *index, *src, std::string(reduce_ptr, reduce_len), (bool)include_self); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__scatter_reduce_two_out(tensor *out__, tensor out, tensor self, int64_t dim, tensor index, tensor src, char* reduce_ptr, int reduce_len, int include_self) { + PROTECT( + auto outputs__ = torch::scatter_reduce_out(*out, *self, dim, *index, *src, std::string(reduce_ptr, reduce_len), (bool)include_self); + out__[0] = new torch::Tensor(outputs__); ) } @@ -2179,9 +2248,9 @@ void atg__sparse_compressed_tensor_unsafe(tensor *out__, tensor compressed_indic ) } -void atg__sparse_coo_tensor_unsafe(tensor *out__, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device) { +void atg__sparse_coo_tensor_unsafe(tensor *out__, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device, int is_coalesced) { PROTECT( - auto outputs__ = torch::_sparse_coo_tensor_unsafe(*indices, *values, torch::IntArrayRef(size_data, size_len), at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind))); + auto outputs__ = torch::_sparse_coo_tensor_unsafe(*indices, *values, torch::IntArrayRef(size_data, size_len), at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind)), (bool)is_coalesced); out__[0] = new torch::Tensor(outputs__); ) } @@ -2193,16 +2262,16 @@ void atg__sparse_coo_tensor_with_dims(tensor *out__, int64_t sparse_dim, int64_t ) } -void atg__sparse_coo_tensor_with_dims_and_tensors(tensor *out__, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values, int options_kind, int options_device) { +void atg__sparse_coo_tensor_with_dims_and_tensors(tensor *out__, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values, int options_kind, int options_device, int is_coalesced) { PROTECT( - auto outputs__ = torch::_sparse_coo_tensor_with_dims_and_tensors(sparse_dim, dense_dim, torch::IntArrayRef(size_data, size_len), *indices, *values, at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind))); + auto outputs__ = torch::_sparse_coo_tensor_with_dims_and_tensors(sparse_dim, dense_dim, torch::IntArrayRef(size_data, size_len), *indices, *values, at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind)), (bool)is_coalesced); out__[0] = new torch::Tensor(outputs__); ) } -void atg__sparse_coo_tensor_with_dims_and_tensors_out(tensor *out__, tensor out, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values) { +void atg__sparse_coo_tensor_with_dims_and_tensors_out(tensor *out__, tensor out, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values, int is_coalesced) { PROTECT( - auto outputs__ = torch::_sparse_coo_tensor_with_dims_and_tensors_out(*out, sparse_dim, dense_dim, torch::IntArrayRef(size_data, size_len), *indices, *values); + auto outputs__ = torch::_sparse_coo_tensor_with_dims_and_tensors_out(*out, sparse_dim, dense_dim, torch::IntArrayRef(size_data, size_len), *indices, *values, (bool)is_coalesced); out__[0] = new torch::Tensor(outputs__); ) } @@ -2291,6 +2360,20 @@ void atg__sparse_log_softmax_out(tensor *out__, tensor out, tensor self, int64_t ) } +void atg__sparse_mask_projection(tensor *out__, tensor self, tensor mask, int accumulate_matches) { + PROTECT( + auto outputs__ = self->_sparse_mask_projection(*mask, (bool)accumulate_matches); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__sparse_mask_projection_out(tensor *out__, tensor out, tensor self, tensor mask, int accumulate_matches) { + PROTECT( + auto outputs__ = torch::_sparse_mask_projection_out(*out, *self, *mask, (bool)accumulate_matches); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__sparse_mm(tensor *out__, tensor sparse, tensor dense) { PROTECT( auto outputs__ = torch::_sparse_mm(*sparse, *dense); @@ -2313,6 +2396,13 @@ void atg__sparse_mm_reduce_impl(tensor *out__, tensor self, tensor other, char* ) } +void atg__sparse_semi_structured_linear(tensor *out__, tensor input, tensor weight, tensor meta, tensor bias, char* activation_ptr, int activation_len) { + PROTECT( + auto outputs__ = torch::_sparse_semi_structured_linear(*input, *weight, *meta, (bias ? *bias : torch::Tensor()), std::string(activation_ptr, activation_len)); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__sparse_softmax(tensor *out__, tensor self, int64_t dim, int half_to_float) { PROTECT( auto outputs__ = torch::_sparse_softmax(*self, dim, (bool)half_to_float); @@ -2530,6 +2620,20 @@ void atg__test_check_tensor(tensor *out__, tensor self) { ) } +void atg__test_functorch_fallback(tensor *out__, tensor self, tensor other) { + PROTECT( + auto outputs__ = torch::_test_functorch_fallback(*self, *other); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__test_functorch_fallback_out(tensor *out__, tensor out, tensor self, tensor other) { + PROTECT( + auto outputs__ = torch::_test_functorch_fallback_out(*out, *self, *other); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__test_optional_filled_intlist(tensor *out__, tensor values, int64_t *addends_data, int addends_len) { PROTECT( auto outputs__ = torch::_test_optional_filled_intlist(*values, addends_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(addends_data, addends_len))); @@ -2627,16 +2731,108 @@ tensor *atg__to_cpu(tensor *tensors_data, int tensors_len) { return nullptr; } -void atg__to_dense(tensor *out__, tensor self, int dtype) { +void atg__to_dense(tensor *out__, tensor self, int dtype, int masked_grad) { PROTECT( - auto outputs__ = self->_to_dense(dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(dtype))); + auto outputs__ = self->_to_dense(dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(dtype)), (bool)masked_grad); out__[0] = new torch::Tensor(outputs__); ) } -void atg__to_dense_out(tensor *out__, tensor out, tensor self, int dtype) { +void atg__to_dense_out(tensor *out__, tensor out, tensor self, int dtype, int masked_grad) { PROTECT( - auto outputs__ = torch::_to_dense_out(*out, *self, dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(dtype))); + auto outputs__ = torch::_to_dense_out(*out, *self, dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(dtype)), (bool)masked_grad); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse(tensor *out__, tensor self, int8_t layout, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = self->_to_sparse((layout == -1 ? c10::nullopt : c10::optional(static_cast(layout))), blocksize_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(blocksize_data, blocksize_len)), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_bsc(tensor *out__, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = self->_to_sparse_bsc(torch::IntArrayRef(blocksize_data, blocksize_len), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_bsc_out(tensor *out__, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = torch::_to_sparse_bsc_out(*out, *self, torch::IntArrayRef(blocksize_data, blocksize_len), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_bsr(tensor *out__, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = self->_to_sparse_bsr(torch::IntArrayRef(blocksize_data, blocksize_len), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_bsr_out(tensor *out__, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = torch::_to_sparse_bsr_out(*out, *self, torch::IntArrayRef(blocksize_data, blocksize_len), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_csc(tensor *out__, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = self->_to_sparse_csc(dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_csc_out(tensor *out__, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = torch::_to_sparse_csc_out(*out, *self, dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_csr(tensor *out__, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = self->_to_sparse_csr(dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_csr_out(tensor *out__, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = torch::_to_sparse_csr_out(*out, *self, dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_out(tensor *out__, tensor out, tensor self, int8_t layout, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { + PROTECT( + auto outputs__ = torch::_to_sparse_out(*out, *self, (layout == -1 ? c10::nullopt : c10::optional(static_cast(layout))), blocksize_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(blocksize_data, blocksize_len)), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_semi_structured(tensor *out__, tensor dense) { + PROTECT( + auto outputs__ = torch::_to_sparse_semi_structured(*dense); + out__[0] = new torch::Tensor(std::get<0>(outputs__)); + out__[1] = new torch::Tensor(std::get<1>(outputs__)); + ) +} + +void atg__to_sparse_sparse_dim(tensor *out__, tensor self, int64_t sparse_dim) { + PROTECT( + auto outputs__ = self->_to_sparse(sparse_dim); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__to_sparse_sparse_dim_out(tensor *out__, tensor out, tensor self, int64_t sparse_dim) { + PROTECT( + auto outputs__ = torch::_to_sparse_out(*out, *self, sparse_dim); out__[0] = new torch::Tensor(outputs__); ) } @@ -2659,24 +2855,6 @@ void atg__transform_bias_rescale_qkv_out(tensor *out__, tensor out0, tensor out1 ) } -void atg__transformer_decoder_only_layer_fwd(tensor *out__, tensor src, int64_t embed_dim, int64_t num_heads, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, int use_gelu, int norm_first, double eps, tensor norm_weight_1, tensor norm_bias_1, tensor norm_weight_2, tensor norm_bias_2, tensor ffn_weight_1, tensor ffn_bias_1, tensor ffn_weight_2, tensor ffn_bias_2, tensor mask, tensor incr_key, tensor incr_value) { - PROTECT( - auto outputs__ = torch::_transformer_decoder_only_layer_fwd(*src, embed_dim, num_heads, *qkv_weight, *qkv_bias, *proj_weight, *proj_bias, (bool)use_gelu, (bool)norm_first, eps, *norm_weight_1, *norm_bias_1, *norm_weight_2, *norm_bias_2, *ffn_weight_1, *ffn_bias_1, *ffn_weight_2, *ffn_bias_2, (mask ? *mask : torch::Tensor()), (incr_key ? *incr_key : torch::Tensor()), (incr_value ? *incr_value : torch::Tensor())); - out__[0] = new torch::Tensor(std::get<0>(outputs__)); - out__[1] = new torch::Tensor(std::get<1>(outputs__)); - out__[2] = new torch::Tensor(std::get<2>(outputs__)); - ) -} - -void atg__transformer_decoder_only_layer_fwd_out(tensor *out__, tensor out0, tensor out1, tensor out2, tensor src, int64_t embed_dim, int64_t num_heads, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, int use_gelu, int norm_first, double eps, tensor norm_weight_1, tensor norm_bias_1, tensor norm_weight_2, tensor norm_bias_2, tensor ffn_weight_1, tensor ffn_bias_1, tensor ffn_weight_2, tensor ffn_bias_2, tensor mask, tensor incr_key, tensor incr_value) { - PROTECT( - auto outputs__ = torch::_transformer_decoder_only_layer_fwd_out(*out0, *out1, *out2, *src, embed_dim, num_heads, *qkv_weight, *qkv_bias, *proj_weight, *proj_bias, (bool)use_gelu, (bool)norm_first, eps, *norm_weight_1, *norm_bias_1, *norm_weight_2, *norm_bias_2, *ffn_weight_1, *ffn_bias_1, *ffn_weight_2, *ffn_bias_2, (mask ? *mask : torch::Tensor()), (incr_key ? *incr_key : torch::Tensor()), (incr_value ? *incr_value : torch::Tensor())); - out__[0] = new torch::Tensor(std::get<0>(outputs__)); - out__[1] = new torch::Tensor(std::get<1>(outputs__)); - out__[2] = new torch::Tensor(std::get<2>(outputs__)); - ) -} - void atg__transformer_encoder_layer_fwd(tensor *out__, tensor src, int64_t embed_dim, int64_t num_heads, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, int use_gelu, int norm_first, double eps, tensor norm_weight_1, tensor norm_bias_1, tensor norm_weight_2, tensor norm_bias_2, tensor ffn_weight_1, tensor ffn_bias_1, tensor ffn_weight_2, tensor ffn_bias_2, tensor mask, int64_t mask_type_v, uint8_t mask_type_null) { PROTECT( auto outputs__ = torch::_transformer_encoder_layer_fwd(*src, embed_dim, num_heads, *qkv_weight, *qkv_bias, *proj_weight, *proj_bias, (bool)use_gelu, (bool)norm_first, eps, *norm_weight_1, *norm_bias_1, *norm_weight_2, *norm_bias_2, *ffn_weight_1, *ffn_bias_1, *ffn_weight_2, *ffn_bias_2, (mask ? *mask : torch::Tensor()), mask_type_null ? c10::nullopt : c10::optional(mask_type_v)); @@ -2775,6 +2953,20 @@ void atg__unpack_dual(tensor *out__, tensor dual, int64_t level) { ) } +void atg__unsafe_index(tensor *out__, tensor self, tensor *indices_data, int indices_len) { + PROTECT( + auto outputs__ = torch::_unsafe_index(*self, of_carray_tensor_opt(indices_data, indices_len)); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg__unsafe_index_put(tensor *out__, tensor self, tensor *indices_data, int indices_len, tensor values, int accumulate) { + PROTECT( + auto outputs__ = torch::_unsafe_index_put(*self, of_carray_tensor_opt(indices_data, indices_len), *values, (bool)accumulate); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg__unsafe_view(tensor *out__, tensor self, int64_t *size_data, int size_len) { PROTECT( auto outputs__ = torch::_unsafe_view(*self, torch::IntArrayRef(size_data, size_len)); @@ -4176,16 +4368,16 @@ void atg_batch_norm(tensor *out__, tensor input, tensor weight, tensor bias, ten ) } -void atg_batch_norm_backward_elemt(tensor *out__, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor mean_dy, tensor mean_dy_xmu, tensor count) { +void atg_batch_norm_backward_elemt(tensor *out__, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor sum_dy, tensor sum_dy_xmu, tensor count) { PROTECT( - auto outputs__ = torch::batch_norm_backward_elemt(*grad_out, *input, *mean, *invstd, (weight ? *weight : torch::Tensor()), *mean_dy, *mean_dy_xmu, *count); + auto outputs__ = torch::batch_norm_backward_elemt(*grad_out, *input, *mean, *invstd, (weight ? *weight : torch::Tensor()), *sum_dy, *sum_dy_xmu, *count); out__[0] = new torch::Tensor(outputs__); ) } -void atg_batch_norm_backward_elemt_out(tensor *out__, tensor out, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor mean_dy, tensor mean_dy_xmu, tensor count) { +void atg_batch_norm_backward_elemt_out(tensor *out__, tensor out, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor sum_dy, tensor sum_dy_xmu, tensor count) { PROTECT( - auto outputs__ = torch::batch_norm_backward_elemt_out(*out, *grad_out, *input, *mean, *invstd, (weight ? *weight : torch::Tensor()), *mean_dy, *mean_dy_xmu, *count); + auto outputs__ = torch::batch_norm_backward_elemt_out(*out, *grad_out, *input, *mean, *invstd, (weight ? *weight : torch::Tensor()), *sum_dy, *sum_dy_xmu, *count); out__[0] = new torch::Tensor(outputs__); ) } @@ -6569,6 +6761,20 @@ void atg_empty_out(tensor *out__, tensor out, int64_t *size_data, int size_len) ) } +void atg_empty_permuted(tensor *out__, int64_t *size_data, int size_len, int64_t *physical_layout_data, int physical_layout_len, int options_kind, int options_device) { + PROTECT( + auto outputs__ = torch::empty_permuted(torch::IntArrayRef(size_data, size_len), torch::IntArrayRef(physical_layout_data, physical_layout_len), at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind))); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg_empty_permuted_out(tensor *out__, tensor out, int64_t *size_data, int size_len, int64_t *physical_layout_data, int physical_layout_len) { + PROTECT( + auto outputs__ = torch::empty_permuted_out(*out, torch::IntArrayRef(size_data, size_len), torch::IntArrayRef(physical_layout_data, physical_layout_len)); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg_empty_quantized(tensor *out__, int64_t *size_data, int size_len, tensor qtensor, int options_kind, int options_device) { PROTECT( auto outputs__ = torch::empty_quantized(torch::IntArrayRef(size_data, size_len), *qtensor, at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind))); @@ -11072,6 +11278,13 @@ void atg_min_out(tensor *out__, tensor out, tensor self, tensor other) { ) } +void atg_min_unary_out(tensor *out__, tensor out, tensor self) { + PROTECT( + auto outputs__ = torch::min_out(*out, *self); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg_minimum(tensor *out__, tensor self, tensor other) { PROTECT( auto outputs__ = torch::minimum(*self, *other); @@ -12245,6 +12458,20 @@ void atg_nonzero_out(tensor *out__, tensor out, tensor self) { ) } +void atg_nonzero_static(tensor *out__, tensor self, int64_t size, int64_t fill_value) { + PROTECT( + auto outputs__ = torch::nonzero_static(*self, size, fill_value); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg_nonzero_static_out(tensor *out__, tensor out, tensor self, int64_t size, int64_t fill_value) { + PROTECT( + auto outputs__ = torch::nonzero_static_out(*out, *self, size, fill_value); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg_norm(tensor *out__, tensor self) { PROTECT( auto outputs__ = torch::norm(*self); @@ -12954,6 +13181,20 @@ void atg_quantized_max_pool2d_out(tensor *out__, tensor out, tensor self, int64_ ) } +void atg_quantized_max_pool3d(tensor *out__, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) { + PROTECT( + auto outputs__ = torch::quantized_max_pool3d(*self, torch::IntArrayRef(kernel_size_data, kernel_size_len), torch::IntArrayRef(stride_data, stride_len), torch::IntArrayRef(padding_data, padding_len), torch::IntArrayRef(dilation_data, dilation_len), (bool)ceil_mode); + out__[0] = new torch::Tensor(outputs__); + ) +} + +void atg_quantized_max_pool3d_out(tensor *out__, tensor out, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode) { + PROTECT( + auto outputs__ = torch::quantized_max_pool3d_out(*out, *self, torch::IntArrayRef(kernel_size_data, kernel_size_len), torch::IntArrayRef(stride_data, stride_len), torch::IntArrayRef(padding_data, padding_len), torch::IntArrayRef(dilation_data, dilation_len), (bool)ceil_mode); + out__[0] = new torch::Tensor(outputs__); + ) +} + void atg_quantized_rnn_relu_cell(tensor *out__, tensor input, tensor hx, tensor w_ih, tensor w_hh, tensor b_ih, tensor b_hh, tensor packed_ih, tensor packed_hh, tensor col_offsets_ih, tensor col_offsets_hh, scalar scale_ih, scalar scale_hh, scalar zero_point_ih, scalar zero_point_hh) { PROTECT( auto outputs__ = torch::quantized_rnn_relu_cell(*input, *hx, *w_ih, *w_hh, *b_ih, *b_hh, *packed_ih, *packed_hh, *col_offsets_ih, *col_offsets_hh, *scale_ih, *scale_hh, *zero_point_ih, *zero_point_hh); @@ -13931,9 +14172,9 @@ void atg_scalar_tensor_out(tensor *out__, tensor out, scalar s) { ) } -void atg_scaled_dot_product_attention(tensor *out__, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal) { +void atg_scaled_dot_product_attention(tensor *out__, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, double scale_v, uint8_t scale_null) { PROTECT( - auto outputs__ = torch::scaled_dot_product_attention(*query, *key, *value, (attn_mask ? *attn_mask : torch::Tensor()), dropout_p, (bool)is_causal); + auto outputs__ = torch::scaled_dot_product_attention(*query, *key, *value, (attn_mask ? *attn_mask : torch::Tensor()), dropout_p, (bool)is_causal, scale_null ? c10::nullopt : c10::optional(scale_v)); out__[0] = new torch::Tensor(outputs__); ) } @@ -14742,16 +14983,16 @@ void atg_sparse_coo_tensor(tensor *out__, int64_t *size_data, int size_len, int ) } -void atg_sparse_coo_tensor_indices(tensor *out__, tensor indices, tensor values, int options_kind, int options_device) { +void atg_sparse_coo_tensor_indices(tensor *out__, tensor indices, tensor values, int options_kind, int options_device, int is_coalesced) { PROTECT( - auto outputs__ = torch::sparse_coo_tensor(*indices, *values, at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind))); + auto outputs__ = torch::sparse_coo_tensor(*indices, *values, at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind)), (bool)is_coalesced); out__[0] = new torch::Tensor(outputs__); ) } -void atg_sparse_coo_tensor_indices_size(tensor *out__, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device) { +void atg_sparse_coo_tensor_indices_size(tensor *out__, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device, int is_coalesced) { PROTECT( - auto outputs__ = torch::sparse_coo_tensor(*indices, *values, torch::IntArrayRef(size_data, size_len), at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind))); + auto outputs__ = torch::sparse_coo_tensor(*indices, *values, torch::IntArrayRef(size_data, size_len), at::device(device_of_int(options_device)).dtype(at::ScalarType(options_kind)), (bool)is_coalesced); out__[0] = new torch::Tensor(outputs__); ) } @@ -16284,16 +16525,16 @@ void atg_std(tensor *out__, tensor self, int unbiased) { ) } -void atg_std_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_std_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::std(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::std(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(outputs__); ) } -void atg_std_correction_out(tensor *out__, tensor out, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_std_correction_out(tensor *out__, tensor out, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::std_out(*out, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::std_out(*out, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(outputs__); ) } @@ -16313,17 +16554,17 @@ void atg_std_mean(tensor *out__, tensor self, int unbiased) { ) } -void atg_std_mean_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_std_mean_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::std_mean(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::std_mean(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); ) } -void atg_std_mean_correction_out(tensor *out__, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_std_mean_correction_out(tensor *out__, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::std_mean_out(*out0, *out1, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::std_mean_out(*out0, *out1, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); ) @@ -16516,6 +16757,18 @@ void atg_swapdims_(tensor *out__, tensor self, int64_t dim0, int64_t dim1) { ) } +void atg_sym_constrain_range(scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null) { + PROTECT( + torch::sym_constrain_range(*size, min_null ? c10::nullopt : c10::optional(min_v), max_null ? c10::nullopt : c10::optional(max_v)); + ) +} + +void atg_sym_constrain_range_for_size(scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null) { + PROTECT( + torch::sym_constrain_range_for_size(*size, min_null ? c10::nullopt : c10::optional(min_v), max_null ? c10::nullopt : c10::optional(max_v)); + ) +} + void atg_t(tensor *out__, tensor self) { PROTECT( auto outputs__ = torch::t(*self); @@ -16730,16 +16983,16 @@ void atg_to(tensor *out__, tensor self, int device) { ) } -void atg_to_dense(tensor *out__, tensor self, int dtype) { +void atg_to_dense(tensor *out__, tensor self, int dtype, int masked_grad) { PROTECT( - auto outputs__ = self->to_dense(dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(dtype))); + auto outputs__ = self->to_dense(dtype < 0 ? c10::nullopt : c10::optional(at::ScalarType(dtype)), (bool)masked_grad); out__[0] = new torch::Tensor(outputs__); ) } -void atg_to_dense_backward(tensor *out__, tensor grad, tensor input) { +void atg_to_dense_backward(tensor *out__, tensor grad, tensor input, int masked_grad) { PROTECT( - auto outputs__ = torch::to_dense_backward(*grad, *input); + auto outputs__ = torch::to_dense_backward(*grad, *input, (bool)masked_grad); out__[0] = new torch::Tensor(outputs__); ) } @@ -16821,13 +17074,6 @@ void atg_to_sparse_bsc(tensor *out__, tensor self, int64_t *blocksize_data, int ) } -void atg_to_sparse_bsc_out(tensor *out__, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { - PROTECT( - auto outputs__ = torch::to_sparse_bsc_out(*out, *self, torch::IntArrayRef(blocksize_data, blocksize_len), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); - out__[0] = new torch::Tensor(outputs__); - ) -} - void atg_to_sparse_bsr(tensor *out__, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { PROTECT( auto outputs__ = self->to_sparse_bsr(torch::IntArrayRef(blocksize_data, blocksize_len), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); @@ -16835,13 +17081,6 @@ void atg_to_sparse_bsr(tensor *out__, tensor self, int64_t *blocksize_data, int ) } -void atg_to_sparse_bsr_out(tensor *out__, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { - PROTECT( - auto outputs__ = torch::to_sparse_bsr_out(*out, *self, torch::IntArrayRef(blocksize_data, blocksize_len), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); - out__[0] = new torch::Tensor(outputs__); - ) -} - void atg_to_sparse_csc(tensor *out__, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { PROTECT( auto outputs__ = self->to_sparse_csc(dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); @@ -16849,13 +17088,6 @@ void atg_to_sparse_csc(tensor *out__, tensor self, int64_t dense_dim_v, uint8_t ) } -void atg_to_sparse_csc_out(tensor *out__, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { - PROTECT( - auto outputs__ = torch::to_sparse_csc_out(*out, *self, dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); - out__[0] = new torch::Tensor(outputs__); - ) -} - void atg_to_sparse_csr(tensor *out__, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { PROTECT( auto outputs__ = self->to_sparse_csr(dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); @@ -16863,20 +17095,6 @@ void atg_to_sparse_csr(tensor *out__, tensor self, int64_t dense_dim_v, uint8_t ) } -void atg_to_sparse_csr_out(tensor *out__, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null) { - PROTECT( - auto outputs__ = torch::to_sparse_csr_out(*out, *self, dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); - out__[0] = new torch::Tensor(outputs__); - ) -} - -void atg_to_sparse_out(tensor *out__, tensor out, tensor self, int8_t layout, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null) { - PROTECT( - auto outputs__ = torch::to_sparse_out(*out, *self, (layout == -1 ? c10::nullopt : c10::optional(static_cast(layout))), blocksize_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(blocksize_data, blocksize_len)), dense_dim_null ? c10::nullopt : c10::optional(dense_dim_v)); - out__[0] = new torch::Tensor(outputs__); - ) -} - void atg_to_sparse_sparse_dim(tensor *out__, tensor self, int64_t sparse_dim) { PROTECT( auto outputs__ = self->to_sparse(sparse_dim); @@ -16884,13 +17102,6 @@ void atg_to_sparse_sparse_dim(tensor *out__, tensor self, int64_t sparse_dim) { ) } -void atg_to_sparse_sparse_dim_out(tensor *out__, tensor out, tensor self, int64_t sparse_dim) { - PROTECT( - auto outputs__ = torch::to_sparse_out(*out, *self, sparse_dim); - out__[0] = new torch::Tensor(outputs__); - ) -} - void atg_topk(tensor *out__, tensor self, int64_t k, int64_t dim, int largest, int sorted) { PROTECT( auto outputs__ = torch::topk(*self, k, dim, (bool)largest, (bool)sorted); @@ -17657,16 +17868,16 @@ void atg_var(tensor *out__, tensor self, int unbiased) { ) } -void atg_var_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_var_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::var(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::var(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(outputs__); ) } -void atg_var_correction_out(tensor *out__, tensor out, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_var_correction_out(tensor *out__, tensor out, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::var_out(*out, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::var_out(*out, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(outputs__); ) } @@ -17686,17 +17897,17 @@ void atg_var_mean(tensor *out__, tensor self, int unbiased) { ) } -void atg_var_mean_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_var_mean_correction(tensor *out__, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::var_mean(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::var_mean(*self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); ) } -void atg_var_mean_correction_out(tensor *out__, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim) { +void atg_var_mean_correction_out(tensor *out__, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim) { PROTECT( - auto outputs__ = torch::var_mean_out(*out0, *out1, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), correction_null ? c10::nullopt : c10::optional(correction_v), (bool)keepdim); + auto outputs__ = torch::var_mean_out(*out0, *out1, *self, dim_data == nullptr ? c10::nullopt : c10::optional(torch::IntArrayRef(dim_data, dim_len)), *correction, (bool)keepdim); out__[0] = new torch::Tensor(std::get<0>(outputs__)); out__[1] = new torch::Tensor(std::get<1>(outputs__)); ) diff --git a/libtch/torch_api_generated.h b/libtch/torch_api_generated.h index 92829c1..d4d0615 100644 --- a/libtch/torch_api_generated.h +++ b/libtch/torch_api_generated.h @@ -62,7 +62,6 @@ void atg__cdist_backward(tensor *, tensor grad, tensor x1, tensor x2, double p, void atg__cdist_backward_out(tensor *, tensor out, tensor grad, tensor x1, tensor x2, double p, tensor cdist); void atg__cholesky_solve_helper(tensor *, tensor self, tensor A, int upper); void atg__cholesky_solve_helper_out(tensor *, tensor out, tensor self, tensor A, int upper); -int atg__chunk_grad_outputs_efficient_attention(tensor query, tensor key, tensor value, int is_causal); void atg__coalesce(tensor *, tensor self); void atg__coalesce_out(tensor *, tensor out, tensor self); void atg__coalesced(tensor *, tensor self, int coalesced); @@ -89,6 +88,8 @@ void atg__copy_from(tensor *, tensor self, tensor dst, int non_blocking); void atg__copy_from_and_resize(tensor *, tensor self, tensor dst); void atg__copy_from_and_resize_out(tensor *, tensor out, tensor self, tensor dst); void atg__copy_from_out(tensor *, tensor out, tensor self, tensor dst, int non_blocking); +void atg__cslt_compress(tensor *, tensor input); +void atg__cslt_sparse_mm(tensor *, tensor compressed_A, tensor dense_B, tensor bias, int transpose_result); void atg__ctc_loss(tensor *, tensor log_probs, tensor targets, int64_t *input_lengths_data, int input_lengths_len, int64_t *target_lengths_data, int target_lengths_len, int64_t blank, int zero_infinity); void atg__ctc_loss_backward(tensor *, tensor grad, tensor log_probs, tensor targets, int64_t *input_lengths_data, int input_lengths_len, int64_t *target_lengths_data, int target_lengths_len, tensor neg_log_likelihood, tensor log_alpha, int64_t blank, int zero_infinity); void atg__ctc_loss_backward_out(tensor *, tensor out, tensor grad, tensor log_probs, tensor targets, int64_t *input_lengths_data, int input_lengths_len, int64_t *target_lengths_data, int target_lengths_len, tensor neg_log_likelihood, tensor log_alpha, int64_t blank, int zero_infinity); @@ -105,15 +106,13 @@ void atg__cudnn_rnn(tensor *, tensor input, tensor *weight_data, int weight_len, void atg__cudnn_rnn_flatten_weight(tensor *, tensor *weight_arr_data, int weight_arr_len, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, int batch_first, int bidirectional); void atg__cudnn_rnn_flatten_weight_out(tensor *, tensor out, tensor *weight_arr_data, int weight_arr_len, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, int batch_first, int bidirectional); void atg__cudnn_rnn_out(tensor *, tensor out0, tensor out1, tensor out2, tensor out3, tensor out4, tensor input, tensor *weight_data, int weight_len, int64_t weight_stride0, tensor weight_buf, tensor hx, tensor cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, int batch_first, double dropout, int train, int bidirectional, int64_t *batch_sizes_data, int batch_sizes_len, tensor dropout_state); -int64_t atg__cufft_get_plan_cache_max_size(int64_t device_index); -int64_t atg__cufft_get_plan_cache_size(int64_t device_index); int64_t atg__debug_has_internal_overlap(tensor self); void atg__dim_arange(tensor *, tensor like, int64_t dim); int64_t atg__dimi(tensor self); int64_t atg__dimv(tensor self); void atg__dirichlet_grad(tensor *, tensor x, tensor alpha, tensor total); void atg__dirichlet_grad_out(tensor *, tensor out, tensor x, tensor alpha, tensor total); -void atg__efficient_attention_backward(tensor *, tensor grad_out_, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, int is_causal, int chunk_grad_outputs); +void atg__efficient_attention_backward(tensor *, tensor grad_out_, tensor query, tensor key, tensor value, tensor bias, tensor out, tensor cu_seqlens_q, tensor cu_seqlens_k, int64_t max_seqlen_k, int64_t max_seqlen_q, tensor logsumexp, double dropout_p, tensor philox_seed, tensor philox_offset, int64_t custom_mask_type, int bias_requires_grad, double scale_v, uint8_t scale_null, int64_t num_splits_key_v, uint8_t num_splits_key_null); void atg__efficientzerotensor(tensor *, int64_t *size_data, int size_len, int options_kind, int options_device); void atg__efficientzerotensor_out(tensor *, tensor out, int64_t *size_data, int size_len); void atg__embedding_bag(tensor *, tensor weight, tensor indices, tensor offsets, int scale_grad_by_freq, int64_t mode, int sparse, tensor per_sample_weights, int include_last_offset, int64_t padding_idx); @@ -146,15 +145,19 @@ void atg__fft_c2r(tensor *, tensor self, int64_t *dim_data, int dim_len, int64_t void atg__fft_c2r_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, int64_t normalization, int64_t last_dim_size); void atg__fft_r2c(tensor *, tensor self, int64_t *dim_data, int dim_len, int64_t normalization, int onesided); void atg__fft_r2c_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, int64_t normalization, int onesided); -void atg__flash_attention_backward(tensor *, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, int64_t philox_seed, int64_t philox_offset); +void atg__fill_mem_eff_dropout_mask_(tensor *, tensor self, double dropout_p, int64_t seed, int64_t offset); +void atg__flash_attention_backward(tensor *, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, tensor philox_seed, tensor philox_offset, double scale_v, uint8_t scale_null); void atg__foobar(tensor *, tensor self, int arg1, int arg2, int arg3); void atg__foobar_out(tensor *, tensor out, tensor self, int arg1, int arg2, int arg3); +void atg__functional_assert_async(tensor *, tensor self, char* assert_msg_ptr, int assert_msg_len, tensor dep_token); +void atg__functional_sym_constrain_range(tensor *, scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null, tensor dep_token); +void atg__functional_sym_constrain_range_for_size(tensor *, scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null, tensor dep_token); void atg__fused_dropout(tensor *, tensor self, double p); void atg__fused_dropout_out(tensor *, tensor out0, tensor out1, tensor self, double p); void atg__fused_moving_avg_obs_fq_helper(tensor *, tensor self, tensor observer_on, tensor fake_quant_on, tensor running_min, tensor running_max, tensor scale, tensor zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, int per_row_fake_quant, int symmetric_quant); void atg__fused_moving_avg_obs_fq_helper_functional(tensor *, tensor self, tensor observer_on, tensor fake_quant_on, tensor running_min, tensor running_max, tensor scale, tensor zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, int per_row_fake_quant, int symmetric_quant); void atg__fused_moving_avg_obs_fq_helper_out(tensor *, tensor out0, tensor out1, tensor self, tensor observer_on, tensor fake_quant_on, tensor running_min, tensor running_max, tensor scale, tensor zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, int per_row_fake_quant, int symmetric_quant); -int64_t atg__fused_sdp_choice(tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal); +int64_t atg__fused_sdp_choice(tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, double scale_v, uint8_t scale_null); void atg__fw_primal(tensor *, tensor self, int64_t level); void atg__fw_primal_copy(tensor *, tensor self, int64_t level); void atg__fw_primal_copy_out(tensor *, tensor out, tensor self, int64_t level); @@ -173,6 +176,8 @@ void atg__index_put_impl_out(tensor *, tensor out, tensor self, tensor *indices_ void atg__indices(tensor *, tensor self); void atg__indices_copy(tensor *, tensor self); void atg__indices_copy_out(tensor *, tensor out, tensor self); +void atg__int_mm(tensor *, tensor self, tensor mat2); +void atg__int_mm_out(tensor *, tensor out, tensor self, tensor mat2); void atg__is_all_true(tensor *, tensor self); void atg__is_any_true(tensor *, tensor self); int atg__is_zerotensor(tensor self); @@ -195,6 +200,7 @@ void atg__logcumsumexp_out(tensor *, tensor out, tensor self, int64_t dim); void atg__lstm_mps(tensor *, tensor input, tensor *hx_data, int hx_len, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional, int batch_first); void atg__lstm_mps_out(tensor *, tensor out0, tensor out1, tensor out2, tensor out3, tensor out4, tensor out5, tensor input, tensor *hx_data, int hx_len, tensor *params_data, int params_len, int has_biases, int64_t num_layers, double dropout, int train, int bidirectional, int batch_first); void atg__lu_with_info(tensor *, tensor self, int pivot, int check_errors); +void atg__make_dep_token(tensor *, int options_kind, int options_device); void atg__make_dual(tensor *, tensor primal, tensor tangent, int64_t level); void atg__make_dual_copy(tensor *, tensor primal, tensor tangent, int64_t level); void atg__make_dual_copy_out(tensor *, tensor out, tensor primal, tensor tangent, int64_t level); @@ -221,9 +227,9 @@ void atg__native_batch_norm_legit(tensor *, tensor input, tensor weight, tensor void atg__native_batch_norm_legit_functional(tensor *, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double momentum, double eps); void atg__native_batch_norm_legit_no_stats(tensor *, tensor input, tensor weight, tensor bias, int training, double momentum, double eps); void atg__native_batch_norm_legit_no_stats_out(tensor *, tensor out, tensor save_mean, tensor save_invstd, tensor input, tensor weight, tensor bias, int training, double momentum, double eps); +void atg__native_batch_norm_legit_no_training(tensor *, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, double momentum, double eps); +void atg__native_batch_norm_legit_no_training_out(tensor *, tensor out0, tensor out1, tensor out2, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, double momentum, double eps); void atg__native_batch_norm_legit_out(tensor *, tensor out, tensor save_mean, tensor save_invstd, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double momentum, double eps); -void atg__native_decoder_only_multi_head_attention(tensor *, tensor query, tensor key, tensor value, int64_t embed_dim, int64_t num_head, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, tensor mask, tensor incr_key, tensor incr_value, int need_weights, int average_attn_weights); -void atg__native_decoder_only_multi_head_attention_out(tensor *, tensor out0, tensor out1, tensor out2, tensor out3, tensor query, tensor key, tensor value, int64_t embed_dim, int64_t num_head, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, tensor mask, tensor incr_key, tensor incr_value, int need_weights, int average_attn_weights); void atg__native_multi_head_attention(tensor *, tensor query, tensor key, tensor value, int64_t embed_dim, int64_t num_head, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, tensor mask, int need_weights, int average_attn_weights, int64_t mask_type_v, uint8_t mask_type_null); void atg__native_multi_head_attention_out(tensor *, tensor out0, tensor out1, tensor query, tensor key, tensor value, int64_t embed_dim, int64_t num_head, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, tensor mask, int need_weights, int average_attn_weights, int64_t mask_type_v, uint8_t mask_type_null); void atg__neg_view(tensor *, tensor self); @@ -235,9 +241,9 @@ void atg__nested_from_padded_and_nested_example_out(tensor *, tensor out, tensor void atg__nested_from_padded_out(tensor *, tensor out, tensor padded, tensor cpu_nested_shape_example, int fuse_transform_0213); void atg__nested_select_backward(tensor *, tensor grad_output, tensor self, int64_t dim, int64_t index); void atg__nested_sum_backward(tensor *, tensor grad, tensor self, int64_t *dim_data, int dim_len, int keepdim); -void atg__nested_view_from_buffer(tensor *, tensor self, tensor nested_size, tensor nested_strides, int64_t *offsets_data, int offsets_len); -void atg__nested_view_from_buffer_copy(tensor *, tensor self, tensor nested_size, tensor nested_strides, int64_t *offsets_data, int offsets_len); -void atg__nested_view_from_buffer_copy_out(tensor *, tensor out, tensor self, tensor nested_size, tensor nested_strides, int64_t *offsets_data, int offsets_len); +void atg__nested_view_from_buffer(tensor *, tensor self, tensor nested_size, tensor nested_strides, tensor offsets); +void atg__nested_view_from_buffer_copy(tensor *, tensor self, tensor nested_size, tensor nested_strides, tensor offsets); +void atg__nested_view_from_buffer_copy_out(tensor *, tensor out, tensor self, tensor nested_size, tensor nested_strides, tensor offsets); void atg__new_zeros_with_same_feature_meta(tensor *, tensor self, tensor other, int64_t self_num_batch_dims); void atg__new_zeros_with_same_feature_meta_out(tensor *, tensor out, tensor self, tensor other, int64_t self_num_batch_dims); int atg__nnpack_available(); @@ -256,6 +262,7 @@ void atg__pin_memory(tensor *, tensor self, int device); void atg__pin_memory_out(tensor *, tensor out, tensor self, int device); void atg__prelu_kernel(tensor *, tensor self, tensor weight); void atg__prelu_kernel_backward(tensor *, tensor grad_output, tensor self, tensor weight); +void atg__propagate_xla_data(tensor input, tensor output); void atg__remove_batch_dim(tensor *, tensor self, int64_t level, int64_t batch_size, int64_t out_dim); void atg__reshape_alias(tensor *, tensor self, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len); void atg__reshape_alias_copy(tensor *, tensor self, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len); @@ -269,11 +276,14 @@ void atg__rowwise_prune(tensor *, tensor weight, tensor mask, int compressed_ind void atg__sample_dirichlet(tensor *, tensor self); void atg__sample_dirichlet_out(tensor *, tensor out, tensor self); void atg__saturate_weight_to_fp16(tensor *, tensor weight); -void atg__scaled_dot_product_attention(tensor *, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int need_attn_weights, int is_causal); -void atg__scaled_dot_product_attention_math(tensor *, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, tensor dropout_mask); -void atg__scaled_dot_product_efficient_attention(tensor *, tensor query, tensor key, tensor value, int compute_log_sumexp, int is_causal); -void atg__scaled_dot_product_efficient_attention_backward(tensor *, tensor grad_out_, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, int is_causal, int chunk_grad_outputs); -void atg__scaled_dot_product_flash_attention_backward(tensor *, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, int64_t philox_seed, int64_t philox_offset); +void atg__scaled_dot_product_attention_math(tensor *, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, tensor dropout_mask, double scale_v, uint8_t scale_null); +void atg__scaled_dot_product_efficient_attention(tensor *, tensor query, tensor key, tensor value, tensor attn_bias, int compute_log_sumexp, double dropout_p, int is_causal, double scale_v, uint8_t scale_null); +void atg__scaled_dot_product_flash_attention_backward(tensor *, tensor grad_out, tensor query, tensor key, tensor value, tensor out, tensor logsumexp, tensor cum_seq_q, tensor cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, int is_causal, tensor philox_seed, tensor philox_offset, double scale_v, uint8_t scale_null); +void atg__scaled_mm(tensor *, tensor self, tensor mat2, tensor bias, int out_dtype, tensor scale_a, tensor scale_b, tensor scale_result); +void atg__scaled_mm_out(tensor *, tensor out, tensor out_amax, tensor self, tensor mat2, tensor bias, int out_dtype, tensor scale_a, tensor scale_b, tensor scale_result); +void atg__scatter_reduce(tensor *, tensor self, int64_t dim, tensor index, tensor src, char* reduce_ptr, int reduce_len, int include_self); +void atg__scatter_reduce_(tensor *, tensor self, int64_t dim, tensor index, tensor src, char* reduce_ptr, int reduce_len, int include_self); +void atg__scatter_reduce_two_out(tensor *, tensor out, tensor self, int64_t dim, tensor index, tensor src, char* reduce_ptr, int reduce_len, int include_self); void atg__segment_reduce_backward(tensor *, tensor grad, tensor output, tensor data, char* reduce_ptr, int reduce_len, tensor lengths, tensor offsets, int64_t axis, scalar initial); void atg__segment_reduce_backward_out(tensor *, tensor out, tensor grad, tensor output, tensor data, char* reduce_ptr, int reduce_len, tensor lengths, tensor offsets, int64_t axis, scalar initial); void atg__shape_as_tensor(tensor *, tensor self); @@ -294,10 +304,10 @@ void atg__sparse_broadcast_to_copy_out(tensor *, tensor out, tensor self, int64_ void atg__sparse_bsc_tensor_unsafe(tensor *, tensor ccol_indices, tensor row_indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); void atg__sparse_bsr_tensor_unsafe(tensor *, tensor crow_indices, tensor col_indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); void atg__sparse_compressed_tensor_unsafe(tensor *, tensor compressed_indices, tensor plain_indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); -void atg__sparse_coo_tensor_unsafe(tensor *, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); +void atg__sparse_coo_tensor_unsafe(tensor *, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device, int is_coalesced); void atg__sparse_coo_tensor_with_dims(tensor *, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, int options_kind, int options_device); -void atg__sparse_coo_tensor_with_dims_and_tensors(tensor *, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values, int options_kind, int options_device); -void atg__sparse_coo_tensor_with_dims_and_tensors_out(tensor *, tensor out, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values); +void atg__sparse_coo_tensor_with_dims_and_tensors(tensor *, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values, int options_kind, int options_device, int is_coalesced); +void atg__sparse_coo_tensor_with_dims_and_tensors_out(tensor *, tensor out, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len, tensor indices, tensor values, int is_coalesced); void atg__sparse_coo_tensor_with_dims_out(tensor *, tensor out, int64_t sparse_dim, int64_t dense_dim, int64_t *size_data, int size_len); void atg__sparse_csc_tensor_unsafe(tensor *, tensor ccol_indices, tensor row_indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); void atg__sparse_csr_prod(tensor *, tensor self, int64_t *dim_data, int dim_len, int keepdim, int dtype); @@ -310,9 +320,12 @@ void atg__sparse_log_softmax_backward_data(tensor *, tensor grad_output, tensor void atg__sparse_log_softmax_backward_data_out(tensor *, tensor out, tensor grad_output, tensor output, int64_t dim, tensor self); void atg__sparse_log_softmax_int(tensor *, tensor self, int64_t dim, int dtype); void atg__sparse_log_softmax_out(tensor *, tensor out, tensor self, int64_t dim, int half_to_float); +void atg__sparse_mask_projection(tensor *, tensor self, tensor mask, int accumulate_matches); +void atg__sparse_mask_projection_out(tensor *, tensor out, tensor self, tensor mask, int accumulate_matches); void atg__sparse_mm(tensor *, tensor sparse, tensor dense); void atg__sparse_mm_reduce(tensor *, tensor sparse, tensor dense, char* reduce_ptr, int reduce_len); void atg__sparse_mm_reduce_impl(tensor *, tensor self, tensor other, char* reduce_ptr, int reduce_len); +void atg__sparse_semi_structured_linear(tensor *, tensor input, tensor weight, tensor meta, tensor bias, char* activation_ptr, int activation_len); void atg__sparse_softmax(tensor *, tensor self, int64_t dim, int half_to_float); void atg__sparse_softmax_backward_data(tensor *, tensor grad_output, tensor output, int64_t dim, tensor self); void atg__sparse_softmax_backward_data_out(tensor *, tensor out, tensor grad_output, tensor output, int64_t dim, tensor self); @@ -344,6 +357,8 @@ void atg__test_autograd_multiple_dispatch_view(tensor *, tensor self); void atg__test_autograd_multiple_dispatch_view_copy(tensor *, tensor self); void atg__test_autograd_multiple_dispatch_view_copy_out(tensor *, tensor out, tensor self); void atg__test_check_tensor(tensor *, tensor self); +void atg__test_functorch_fallback(tensor *, tensor self, tensor other); +void atg__test_functorch_fallback_out(tensor *, tensor out, tensor self, tensor other); void atg__test_optional_filled_intlist(tensor *, tensor values, int64_t *addends_data, int addends_len); void atg__test_optional_filled_intlist_out(tensor *, tensor out, tensor values, int64_t *addends_data, int addends_len); void atg__test_optional_floatlist(tensor *, tensor values, double *addends_data, int addends_len); @@ -357,12 +372,23 @@ void atg__test_warn_in_autograd_out(tensor *, tensor out, tensor self); void atg__to_copy(tensor *, tensor self, int options_kind, int options_device, int non_blocking); void atg__to_copy_out(tensor *, tensor out, tensor self, int non_blocking); tensor *atg__to_cpu(tensor *tensors_data, int tensors_len); -void atg__to_dense(tensor *, tensor self, int dtype); -void atg__to_dense_out(tensor *, tensor out, tensor self, int dtype); +void atg__to_dense(tensor *, tensor self, int dtype, int masked_grad); +void atg__to_dense_out(tensor *, tensor out, tensor self, int dtype, int masked_grad); +void atg__to_sparse(tensor *, tensor self, int8_t layout, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_bsc(tensor *, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_bsc_out(tensor *, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_bsr(tensor *, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_bsr_out(tensor *, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_csc(tensor *, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_csc_out(tensor *, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_csr(tensor *, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_csr_out(tensor *, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_out(tensor *, tensor out, tensor self, int8_t layout, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); +void atg__to_sparse_semi_structured(tensor *, tensor dense); +void atg__to_sparse_sparse_dim(tensor *, tensor self, int64_t sparse_dim); +void atg__to_sparse_sparse_dim_out(tensor *, tensor out, tensor self, int64_t sparse_dim); void atg__transform_bias_rescale_qkv(tensor *, tensor qkv, tensor qkv_bias, int64_t num_heads); void atg__transform_bias_rescale_qkv_out(tensor *, tensor out0, tensor out1, tensor out2, tensor qkv, tensor qkv_bias, int64_t num_heads); -void atg__transformer_decoder_only_layer_fwd(tensor *, tensor src, int64_t embed_dim, int64_t num_heads, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, int use_gelu, int norm_first, double eps, tensor norm_weight_1, tensor norm_bias_1, tensor norm_weight_2, tensor norm_bias_2, tensor ffn_weight_1, tensor ffn_bias_1, tensor ffn_weight_2, tensor ffn_bias_2, tensor mask, tensor incr_key, tensor incr_value); -void atg__transformer_decoder_only_layer_fwd_out(tensor *, tensor out0, tensor out1, tensor out2, tensor src, int64_t embed_dim, int64_t num_heads, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, int use_gelu, int norm_first, double eps, tensor norm_weight_1, tensor norm_bias_1, tensor norm_weight_2, tensor norm_bias_2, tensor ffn_weight_1, tensor ffn_bias_1, tensor ffn_weight_2, tensor ffn_bias_2, tensor mask, tensor incr_key, tensor incr_value); void atg__transformer_encoder_layer_fwd(tensor *, tensor src, int64_t embed_dim, int64_t num_heads, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, int use_gelu, int norm_first, double eps, tensor norm_weight_1, tensor norm_bias_1, tensor norm_weight_2, tensor norm_bias_2, tensor ffn_weight_1, tensor ffn_bias_1, tensor ffn_weight_2, tensor ffn_bias_2, tensor mask, int64_t mask_type_v, uint8_t mask_type_null); void atg__transformer_encoder_layer_fwd_out(tensor *, tensor out, tensor src, int64_t embed_dim, int64_t num_heads, tensor qkv_weight, tensor qkv_bias, tensor proj_weight, tensor proj_bias, int use_gelu, int norm_first, double eps, tensor norm_weight_1, tensor norm_bias_1, tensor norm_weight_2, tensor norm_bias_2, tensor ffn_weight_1, tensor ffn_bias_1, tensor ffn_weight_2, tensor ffn_bias_2, tensor mask, int64_t mask_type_v, uint8_t mask_type_null); void atg__trilinear(tensor *, tensor i1, tensor i2, tensor i3, int64_t *expand1_data, int expand1_len, int64_t *expand2_data, int expand2_len, int64_t *expand3_data, int expand3_len, int64_t *sumdim_data, int sumdim_len, int64_t unroll_dim); @@ -376,6 +402,8 @@ void atg__unique2(tensor *, tensor self, int sorted, int return_inverse, int ret void atg__unique2_out(tensor *, tensor out0, tensor out1, tensor out2, tensor self, int sorted, int return_inverse, int return_counts); void atg__unique_out(tensor *, tensor out0, tensor out1, tensor self, int sorted, int return_inverse); void atg__unpack_dual(tensor *, tensor dual, int64_t level); +void atg__unsafe_index(tensor *, tensor self, tensor *indices_data, int indices_len); +void atg__unsafe_index_put(tensor *, tensor self, tensor *indices_data, int indices_len, tensor values, int accumulate); void atg__unsafe_view(tensor *, tensor self, int64_t *size_data, int size_len); void atg__unsafe_view_out(tensor *, tensor out, tensor self, int64_t *size_data, int size_len); void atg__upsample_bicubic2d_aa(tensor *, tensor self, int64_t *output_size_data, int output_size_len, int align_corners, double scales_h_v, uint8_t scales_h_null, double scales_w_v, uint8_t scales_w_null); @@ -571,8 +599,8 @@ void atg_bartlett_window_out(tensor *, tensor out, int64_t window_length); void atg_bartlett_window_periodic(tensor *, int64_t window_length, int periodic, int options_kind, int options_device); void atg_bartlett_window_periodic_out(tensor *, tensor out, int64_t window_length, int periodic); void atg_batch_norm(tensor *, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double momentum, double eps, int cudnn_enabled); -void atg_batch_norm_backward_elemt(tensor *, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor mean_dy, tensor mean_dy_xmu, tensor count); -void atg_batch_norm_backward_elemt_out(tensor *, tensor out, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor mean_dy, tensor mean_dy_xmu, tensor count); +void atg_batch_norm_backward_elemt(tensor *, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor sum_dy, tensor sum_dy_xmu, tensor count); +void atg_batch_norm_backward_elemt_out(tensor *, tensor out, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, tensor sum_dy, tensor sum_dy_xmu, tensor count); void atg_batch_norm_backward_reduce(tensor *, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, int input_g, int weight_g, int bias_g); void atg_batch_norm_backward_reduce_out(tensor *, tensor out0, tensor out1, tensor out2, tensor out3, tensor grad_out, tensor input, tensor mean, tensor invstd, tensor weight, int input_g, int weight_g, int bias_g); void atg_batch_norm_elemt(tensor *, tensor input, tensor weight, tensor bias, tensor mean, tensor invstd, double eps); @@ -903,6 +931,8 @@ void atg_empty(tensor *, int64_t *size_data, int size_len, int options_kind, int void atg_empty_like(tensor *, tensor self); void atg_empty_like_out(tensor *, tensor out, tensor self); void atg_empty_out(tensor *, tensor out, int64_t *size_data, int size_len); +void atg_empty_permuted(tensor *, int64_t *size_data, int size_len, int64_t *physical_layout_data, int physical_layout_len, int options_kind, int options_device); +void atg_empty_permuted_out(tensor *, tensor out, int64_t *size_data, int size_len, int64_t *physical_layout_data, int physical_layout_len); void atg_empty_quantized(tensor *, int64_t *size_data, int size_len, tensor qtensor, int options_kind, int options_device); void atg_empty_quantized_out(tensor *, tensor out, int64_t *size_data, int size_len, tensor qtensor); void atg_empty_strided(tensor *, int64_t *size_data, int size_len, int64_t *stride_data, int stride_len, int options_kind, int options_device); @@ -1532,6 +1562,7 @@ void atg_min_dim(tensor *, tensor self, int64_t dim, int keepdim); void atg_min_dim_min(tensor *, tensor min, tensor min_indices, tensor self, int64_t dim, int keepdim); void atg_min_other(tensor *, tensor self, tensor other); void atg_min_out(tensor *, tensor out, tensor self, tensor other); +void atg_min_unary_out(tensor *, tensor out, tensor self); void atg_minimum(tensor *, tensor self, tensor other); void atg_minimum_out(tensor *, tensor out, tensor self, tensor other); void atg_miopen_batch_norm(tensor *, tensor input, tensor weight, tensor bias, tensor running_mean, tensor running_var, int training, double exponential_average_factor, double epsilon); @@ -1691,6 +1722,8 @@ void atg_nll_loss_out(tensor *, tensor out, tensor self, tensor target, tensor w void atg_nonzero(tensor *, tensor self); tensor *atg_nonzero_numpy(tensor self); void atg_nonzero_out(tensor *, tensor out, tensor self); +void atg_nonzero_static(tensor *, tensor self, int64_t size, int64_t fill_value); +void atg_nonzero_static_out(tensor *, tensor out, tensor self, int64_t size, int64_t fill_value); void atg_norm(tensor *, tensor self); void atg_norm_dtype_out(tensor *, tensor out, tensor self, scalar p, int64_t *dim_data, int dim_len, int keepdim, int dtype); void atg_norm_except_dim(tensor *, tensor v, int64_t pow, int64_t dim); @@ -1791,6 +1824,8 @@ void atg_quantized_max_pool1d(tensor *, tensor self, int64_t *kernel_size_data, void atg_quantized_max_pool1d_out(tensor *, tensor out, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode); void atg_quantized_max_pool2d(tensor *, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode); void atg_quantized_max_pool2d_out(tensor *, tensor out, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode); +void atg_quantized_max_pool3d(tensor *, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode); +void atg_quantized_max_pool3d_out(tensor *, tensor out, tensor self, int64_t *kernel_size_data, int kernel_size_len, int64_t *stride_data, int stride_len, int64_t *padding_data, int padding_len, int64_t *dilation_data, int dilation_len, int ceil_mode); void atg_quantized_rnn_relu_cell(tensor *, tensor input, tensor hx, tensor w_ih, tensor w_hh, tensor b_ih, tensor b_hh, tensor packed_ih, tensor packed_hh, tensor col_offsets_ih, tensor col_offsets_hh, scalar scale_ih, scalar scale_hh, scalar zero_point_ih, scalar zero_point_hh); void atg_quantized_rnn_tanh_cell(tensor *, tensor input, tensor hx, tensor w_ih, tensor w_hh, tensor b_ih, tensor b_hh, tensor packed_ih, tensor packed_hh, tensor col_offsets_ih, tensor col_offsets_hh, scalar scale_ih, scalar scale_hh, scalar zero_point_ih, scalar zero_point_hh); void atg_rad2deg(tensor *, tensor self); @@ -1930,7 +1965,7 @@ void atg_rsub_scalar_out(tensor *, tensor out, tensor self, scalar other); void atg_rsub_tensor_out(tensor *, tensor out, tensor self, tensor other); void atg_scalar_tensor(tensor *, scalar s, int options_kind, int options_device); void atg_scalar_tensor_out(tensor *, tensor out, scalar s); -void atg_scaled_dot_product_attention(tensor *, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal); +void atg_scaled_dot_product_attention(tensor *, tensor query, tensor key, tensor value, tensor attn_mask, double dropout_p, int is_causal, double scale_v, uint8_t scale_null); void atg_scatter(tensor *, tensor self, int64_t dim, tensor index, tensor src); void atg_scatter_(tensor *, tensor self, int64_t dim, tensor index, tensor src); void atg_scatter_add(tensor *, tensor self, int64_t dim, tensor index, tensor src); @@ -2045,8 +2080,8 @@ void atg_sparse_bsr_tensor_crow_col_value_size(tensor *, tensor crow_indices, te void atg_sparse_compressed_tensor(tensor *, tensor compressed_indices, tensor plain_indices, tensor values, int options_kind, int options_device); void atg_sparse_compressed_tensor_comp_plain_value_size(tensor *, tensor compressed_indices, tensor plain_indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); void atg_sparse_coo_tensor(tensor *, int64_t *size_data, int size_len, int options_kind, int options_device); -void atg_sparse_coo_tensor_indices(tensor *, tensor indices, tensor values, int options_kind, int options_device); -void atg_sparse_coo_tensor_indices_size(tensor *, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); +void atg_sparse_coo_tensor_indices(tensor *, tensor indices, tensor values, int options_kind, int options_device, int is_coalesced); +void atg_sparse_coo_tensor_indices_size(tensor *, tensor indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device, int is_coalesced); void atg_sparse_coo_tensor_size_out(tensor *, tensor out, int64_t *size_data, int size_len); void atg_sparse_csc_tensor(tensor *, tensor ccol_indices, tensor row_indices, tensor values, int options_kind, int options_device); void atg_sparse_csc_tensor_ccol_row_value_size(tensor *, tensor ccol_indices, tensor row_indices, tensor values, int64_t *size_data, int size_len, int options_kind, int options_device); @@ -2261,12 +2296,12 @@ void atg_sspaddmm_out(tensor *, tensor out, tensor self, tensor mat1, tensor mat void atg_stack(tensor *, tensor *tensors_data, int tensors_len, int64_t dim); void atg_stack_out(tensor *, tensor out, tensor *tensors_data, int tensors_len, int64_t dim); void atg_std(tensor *, tensor self, int unbiased); -void atg_std_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); -void atg_std_correction_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); +void atg_std_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); +void atg_std_correction_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); void atg_std_dim(tensor *, tensor self, int64_t *dim_data, int dim_len, int unbiased, int keepdim); void atg_std_mean(tensor *, tensor self, int unbiased); -void atg_std_mean_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); -void atg_std_mean_correction_out(tensor *, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); +void atg_std_mean_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); +void atg_std_mean_correction_out(tensor *, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); void atg_std_mean_dim(tensor *, tensor self, int64_t *dim_data, int dim_len, int unbiased, int keepdim); void atg_std_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, int unbiased, int keepdim); void atg_stft(tensor *, tensor self, int64_t n_fft, int64_t hop_length_v, uint8_t hop_length_null, int64_t win_length_v, uint8_t win_length_null, tensor window, int normalized, int onesided, int return_complex); @@ -2293,6 +2328,8 @@ void atg_swapaxes(tensor *, tensor self, int64_t axis0, int64_t axis1); void atg_swapaxes_(tensor *, tensor self, int64_t axis0, int64_t axis1); void atg_swapdims(tensor *, tensor self, int64_t dim0, int64_t dim1); void atg_swapdims_(tensor *, tensor self, int64_t dim0, int64_t dim1); +void atg_sym_constrain_range(scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null); +void atg_sym_constrain_range_for_size(scalar size, int64_t min_v, uint8_t min_null, int64_t max_v, uint8_t max_null); void atg_t(tensor *, tensor self); void atg_t_(tensor *, tensor self); void atg_t_copy(tensor *, tensor self); @@ -2321,8 +2358,8 @@ void atg_threshold_backward_grad_input(tensor *, tensor grad_input, tensor grad_ void atg_threshold_out(tensor *, tensor out, tensor self, scalar threshold, scalar value); void atg_tile(tensor *, tensor self, int64_t *dims_data, int dims_len); void atg_to(tensor *, tensor self, int device); -void atg_to_dense(tensor *, tensor self, int dtype); -void atg_to_dense_backward(tensor *, tensor grad, tensor input); +void atg_to_dense(tensor *, tensor self, int dtype, int masked_grad); +void atg_to_dense_backward(tensor *, tensor grad, tensor input, int masked_grad); void atg_to_device(tensor *, tensor self, int device, int dtype, int non_blocking, int copy); void atg_to_dtype(tensor *, tensor self, int dtype, int non_blocking, int copy); void atg_to_dtype_layout(tensor *, tensor self, int options_kind, int options_device, int non_blocking, int copy); @@ -2334,16 +2371,10 @@ void atg_to_padded_tensor(tensor *, tensor self, double padding, int64_t *output void atg_to_padded_tensor_out(tensor *, tensor out, tensor self, double padding, int64_t *output_size_data, int output_size_len); void atg_to_sparse(tensor *, tensor self, int8_t layout, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); void atg_to_sparse_bsc(tensor *, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); -void atg_to_sparse_bsc_out(tensor *, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); void atg_to_sparse_bsr(tensor *, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); -void atg_to_sparse_bsr_out(tensor *, tensor out, tensor self, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); void atg_to_sparse_csc(tensor *, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); -void atg_to_sparse_csc_out(tensor *, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); void atg_to_sparse_csr(tensor *, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); -void atg_to_sparse_csr_out(tensor *, tensor out, tensor self, int64_t dense_dim_v, uint8_t dense_dim_null); -void atg_to_sparse_out(tensor *, tensor out, tensor self, int8_t layout, int64_t *blocksize_data, int blocksize_len, int64_t dense_dim_v, uint8_t dense_dim_null); void atg_to_sparse_sparse_dim(tensor *, tensor self, int64_t sparse_dim); -void atg_to_sparse_sparse_dim_out(tensor *, tensor out, tensor self, int64_t sparse_dim); void atg_topk(tensor *, tensor self, int64_t k, int64_t dim, int largest, int sorted); void atg_topk_values(tensor *, tensor values, tensor indices, tensor self, int64_t k, int64_t dim, int largest, int sorted); void atg_totype(tensor *, tensor self, int scalar_type); @@ -2446,12 +2477,12 @@ void atg_values_copy(tensor *, tensor self); void atg_values_copy_out(tensor *, tensor out, tensor self); void atg_vander(tensor *, tensor x, int64_t n_v, uint8_t n_null, int increasing); void atg_var(tensor *, tensor self, int unbiased); -void atg_var_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); -void atg_var_correction_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); +void atg_var_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); +void atg_var_correction_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); void atg_var_dim(tensor *, tensor self, int64_t *dim_data, int dim_len, int unbiased, int keepdim); void atg_var_mean(tensor *, tensor self, int unbiased); -void atg_var_mean_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); -void atg_var_mean_correction_out(tensor *, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, int64_t correction_v, uint8_t correction_null, int keepdim); +void atg_var_mean_correction(tensor *, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); +void atg_var_mean_correction_out(tensor *, tensor out0, tensor out1, tensor self, int64_t *dim_data, int dim_len, scalar correction, int keepdim); void atg_var_mean_dim(tensor *, tensor self, int64_t *dim_data, int dim_len, int unbiased, int keepdim); void atg_var_out(tensor *, tensor out, tensor self, int64_t *dim_data, int dim_len, int unbiased, int keepdim); void atg_vdot(tensor *, tensor self, tensor other); diff --git a/nn/optimizer_test.go b/nn/optimizer_test.go index 8df7af6..2d44d17 100644 --- a/nn/optimizer_test.go +++ b/nn/optimizer_test.go @@ -38,11 +38,13 @@ func TestOptimizer(t *testing.T) { // Optimization loop for i := 0; i < 50; i++ { - logits := model.ForwardT(x, true) + logits := model.Forward(x) loss := logits.MustMseLoss(y, 1, true) if i%10 == 0 { fmt.Printf("Loss: %.3f\n", loss.MustView([]int64{-1}, false).MustFloat64Value([]int64{0})) } + + loss.MustRequiresGrad_(true) opt.BackwardStep(loss) loss.MustDrop() } diff --git a/setup-gotch.sh b/setup-gotch.sh index 1fea856..42002f5 100644 --- a/setup-gotch.sh +++ b/setup-gotch.sh @@ -1,6 +1,6 @@ #!/bin/bash -GOTCH_VERSION="${GOTCH_VER:-v0.8.0}" +GOTCH_VERSION="${GOTCH_VER:-v0.9.0}" CUDA_VERSION="${CUDA_VER:-11.8}" if [ -z $GOPATH ]; then diff --git a/setup-libtorch.sh b/setup-libtorch.sh index 11693c9..c2ec6dd 100644 --- a/setup-libtorch.sh +++ b/setup-libtorch.sh @@ -1,6 +1,6 @@ #!/bin/bash -LIBTORCH_VERSION="${LIBTORCH_VER:-2.0.1}" +LIBTORCH_VERSION="${LIBTORCH_VER:-2.1.0}" CUDA_VERSION="${CUDA_VER:-11.8}" if [ "${CUDA_VERSION}" == "cpu" ]; then diff --git a/ts/must-tensor-generated.go b/ts/must-tensor-generated.go index 9120973..79655ab 100644 --- a/ts/must-tensor-generated.go +++ b/ts/must-tensor-generated.go @@ -505,14 +505,6 @@ func(ts *Tensor) Must_CholeskySolveHelperOut(out *Tensor, a *Tensor, upper bool, return retVal } -func Must_ChunkGradOutputsEfficientAttention(query *Tensor, key *Tensor, value *Tensor, isCausal bool)(retVal bool) { - - retVal, err := _ChunkGradOutputsEfficientAttention(query, key, value, isCausal) - if err != nil { log.Fatal(err) } - - return retVal -} - func(ts *Tensor) Must_Coalesce(del bool)(retVal *Tensor) { retVal, err := ts._Coalesce(del) @@ -721,6 +713,22 @@ func(ts *Tensor) Must_CopyFromOut(out *Tensor, dst *Tensor, nonBlocking bool, de return retVal } +func Must_CsltCompress(input *Tensor)(retVal *Tensor) { + + retVal, err := _CsltCompress(input) + if err != nil { log.Fatal(err) } + + return retVal +} + +func Must_CsltSparseMm(compressedA *Tensor, denseB *Tensor, bias *Tensor, transposeResult bool)(retVal *Tensor) { + + retVal, err := _CsltSparseMm(compressedA, denseB, bias, transposeResult) + if err != nil { log.Fatal(err) } + + return retVal +} + func Must_CtcLoss(logProbs *Tensor, targets *Tensor, inputLengths []int64, targetLengths []int64, blank int64, zeroInfinity bool)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := _CtcLoss(logProbs, targets, inputLengths, targetLengths, blank, zeroInfinity) @@ -849,22 +857,6 @@ func Must_CudnnRnnOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, out3 *Tensor, ou return retVal0, retVal1, retVal2, retVal3, retVal4 } -func Must_CufftGetPlanCacheMaxSize(deviceIndex int64)(retVal int64) { - - retVal, err := _CufftGetPlanCacheMaxSize(deviceIndex) - if err != nil { log.Fatal(err) } - - return retVal -} - -func Must_CufftGetPlanCacheSize(deviceIndex int64)(retVal int64) { - - retVal, err := _CufftGetPlanCacheSize(deviceIndex) - if err != nil { log.Fatal(err) } - - return retVal -} - func(ts *Tensor) Must_DebugHasInternalOverlap(del bool)(retVal int64) { retVal, err := ts._DebugHasInternalOverlap(del) @@ -913,12 +905,12 @@ func Must_DirichletGradOut(out *Tensor, x *Tensor, alpha *Tensor, total *Tensor) return retVal } -func Must_EfficientAttentionBackward(gradOut_ *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, isCausal bool, chunkGradOutputs bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { +func Must_EfficientAttentionBackward(gradOut_ *Tensor, query *Tensor, key *Tensor, value *Tensor, bias *Tensor, out *Tensor, cuSeqlensQ *Tensor, cuSeqlensK *Tensor, maxSeqlenK int64, maxSeqlenQ int64, logsumexp *Tensor, dropoutP float64, philoxSeed *Tensor, philoxOffset *Tensor, customMaskType int64, biasRequiresGrad bool, scale []float64, numSplitsKey []int64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor) { - retVal0, retVal1, retVal2, err := _EfficientAttentionBackward(gradOut_, query, key, value, out, logsumexp, isCausal, chunkGradOutputs) + retVal0, retVal1, retVal2, retVal3, err := _EfficientAttentionBackward(gradOut_, query, key, value, bias, out, cuSeqlensQ, cuSeqlensK, maxSeqlenK, maxSeqlenQ, logsumexp, dropoutP, philoxSeed, philoxOffset, customMaskType, biasRequiresGrad, scale, numSplitsKey) if err != nil { log.Fatal(err) } - return retVal0, retVal1, retVal2 + return retVal0, retVal1, retVal2, retVal3 } func Must_Efficientzerotensor(size []int64, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { @@ -1177,9 +1169,17 @@ func(ts *Tensor) Must_FftR2cOut(out *Tensor, dim []int64, normalization int64, o return retVal } -func Must_FlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed int64, philoxOffset int64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { +func(ts *Tensor) Must_FillMemEffDropoutMask_(dropoutP float64, seed int64, offset int64)() { - retVal0, retVal1, retVal2, err := _FlashAttentionBackward(gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, maxQ, maxK, dropoutP, isCausal, philoxSeed, philoxOffset) + err := ts._FillMemEffDropoutMask_(dropoutP, seed, offset) + if err != nil { log.Fatal(err) } + + return +} + +func Must_FlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed *Tensor, philoxOffset *Tensor, scale []float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { + + retVal0, retVal1, retVal2, err := _FlashAttentionBackward(gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, maxQ, maxK, dropoutP, isCausal, philoxSeed, philoxOffset, scale) if err != nil { log.Fatal(err) } return retVal0, retVal1, retVal2 @@ -1201,6 +1201,30 @@ func(ts *Tensor) Must_FoobarOut(out *Tensor, arg1 bool, arg2 bool, arg3 bool, de return retVal } +func(ts *Tensor) Must_FunctionalAssertAsync(assertMsg string, depToken *Tensor, del bool)(retVal *Tensor) { + + retVal, err := ts._FunctionalAssertAsync(assertMsg, depToken, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func Must_FunctionalSymConstrainRange(size *Scalar, min []int64, max []int64, depToken *Tensor)(retVal *Tensor) { + + retVal, err := _FunctionalSymConstrainRange(size, min, max, depToken) + if err != nil { log.Fatal(err) } + + return retVal +} + +func Must_FunctionalSymConstrainRangeForSize(size *Scalar, min []int64, max []int64, depToken *Tensor)(retVal *Tensor) { + + retVal, err := _FunctionalSymConstrainRangeForSize(size, min, max, depToken) + if err != nil { log.Fatal(err) } + + return retVal +} + func(ts *Tensor) Must_FusedDropout(p float64, del bool)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := ts._FusedDropout(p, del) @@ -1241,9 +1265,9 @@ func(ts *Tensor) Must_FusedMovingAvgObsFqHelperOut(out0 *Tensor, out1 *Tensor, o return retVal0, retVal1 } -func Must_FusedSdpChoice(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool)(retVal int64) { +func Must_FusedSdpChoice(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, scale []float64)(retVal int64) { - retVal, err := _FusedSdpChoice(query, key, value, attnMask, dropoutP, isCausal) + retVal, err := _FusedSdpChoice(query, key, value, attnMask, dropoutP, isCausal, scale) if err != nil { log.Fatal(err) } return retVal @@ -1385,6 +1409,22 @@ func(ts *Tensor) Must_IndicesCopyOut(out *Tensor, del bool)(retVal *Tensor) { return retVal } +func(ts *Tensor) Must_IntMm(mat2 *Tensor, del bool)(retVal *Tensor) { + + retVal, err := ts._IntMm(mat2, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_IntMmOut(out *Tensor, mat2 *Tensor, del bool)(retVal *Tensor) { + + retVal, err := ts._IntMmOut(out, mat2, del) + if err != nil { log.Fatal(err) } + + return retVal +} + func(ts *Tensor) Must_IsAllTrue(del bool)(retVal *Tensor) { retVal, err := ts._IsAllTrue(del) @@ -1561,6 +1601,14 @@ func(ts *Tensor) Must_LuWithInfo(pivot bool, checkErrors bool, del bool)(retVal0 return retVal0, retVal1, retVal2 } +func Must_MakeDepToken(optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { + + retVal, err := _MakeDepToken(optionsKind, optionsDevice) + if err != nil { log.Fatal(err) } + + return retVal +} + func Must_MakeDual(primal *Tensor, tangent *Tensor, level int64)(retVal *Tensor) { retVal, err := _MakeDual(primal, tangent, level) @@ -1769,6 +1817,22 @@ func Must_NativeBatchNormLegitNoStatsOut(out *Tensor, saveMean *Tensor, saveInvs return retVal0, retVal1, retVal2 } +func Must_NativeBatchNormLegitNoTraining(input *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, momentum float64, eps float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { + + retVal0, retVal1, retVal2, err := _NativeBatchNormLegitNoTraining(input, weight, bias, runningMean, runningVar, momentum, eps) + if err != nil { log.Fatal(err) } + + return retVal0, retVal1, retVal2 +} + +func Must_NativeBatchNormLegitNoTrainingOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, input *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, momentum float64, eps float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { + + retVal0, retVal1, retVal2, err := _NativeBatchNormLegitNoTrainingOut(out0, out1, out2, input, weight, bias, runningMean, runningVar, momentum, eps) + if err != nil { log.Fatal(err) } + + return retVal0, retVal1, retVal2 +} + func Must_NativeBatchNormLegitOut(out *Tensor, saveMean *Tensor, saveInvstd *Tensor, input *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, training bool, momentum float64, eps float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { retVal0, retVal1, retVal2, err := _NativeBatchNormLegitOut(out, saveMean, saveInvstd, input, weight, bias, runningMean, runningVar, training, momentum, eps) @@ -1777,22 +1841,6 @@ func Must_NativeBatchNormLegitOut(out *Tensor, saveMean *Tensor, saveInvstd *Ten return retVal0, retVal1, retVal2 } -func Must_NativeDecoderOnlyMultiHeadAttention(query *Tensor, key *Tensor, value *Tensor, embedDim int64, numHead int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor, needWeights bool, averageAttnWeights bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor) { - - retVal0, retVal1, retVal2, retVal3, err := _NativeDecoderOnlyMultiHeadAttention(query, key, value, embedDim, numHead, qkvWeight, qkvBias, projWeight, projBias, mask, incrKey, incrValue, needWeights, averageAttnWeights) - if err != nil { log.Fatal(err) } - - return retVal0, retVal1, retVal2, retVal3 -} - -func Must_NativeDecoderOnlyMultiHeadAttentionOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, out3 *Tensor, query *Tensor, key *Tensor, value *Tensor, embedDim int64, numHead int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor, needWeights bool, averageAttnWeights bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor) { - - retVal0, retVal1, retVal2, retVal3, err := _NativeDecoderOnlyMultiHeadAttentionOut(out0, out1, out2, out3, query, key, value, embedDim, numHead, qkvWeight, qkvBias, projWeight, projBias, mask, incrKey, incrValue, needWeights, averageAttnWeights) - if err != nil { log.Fatal(err) } - - return retVal0, retVal1, retVal2, retVal3 -} - func Must_NativeMultiHeadAttention(query *Tensor, key *Tensor, value *Tensor, embedDim int64, numHead int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, mask *Tensor, needWeights bool, averageAttnWeights bool, maskType []int64)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := _NativeMultiHeadAttention(query, key, value, embedDim, numHead, qkvWeight, qkvBias, projWeight, projBias, mask, needWeights, averageAttnWeights, maskType) @@ -1881,7 +1929,7 @@ func(ts *Tensor) Must_NestedSumBackward(grad *Tensor, dim []int64, keepdim bool, return retVal } -func(ts *Tensor) Must_NestedViewFromBuffer(nestedSize *Tensor, nestedStrides *Tensor, offsets []int64, del bool)(retVal *Tensor) { +func(ts *Tensor) Must_NestedViewFromBuffer(nestedSize *Tensor, nestedStrides *Tensor, offsets *Tensor, del bool)(retVal *Tensor) { retVal, err := ts._NestedViewFromBuffer(nestedSize, nestedStrides, offsets, del) if err != nil { log.Fatal(err) } @@ -1889,7 +1937,7 @@ func(ts *Tensor) Must_NestedViewFromBuffer(nestedSize *Tensor, nestedStrides *Te return retVal } -func(ts *Tensor) Must_NestedViewFromBufferCopy(nestedSize *Tensor, nestedStrides *Tensor, offsets []int64, del bool)(retVal *Tensor) { +func(ts *Tensor) Must_NestedViewFromBufferCopy(nestedSize *Tensor, nestedStrides *Tensor, offsets *Tensor, del bool)(retVal *Tensor) { retVal, err := ts._NestedViewFromBufferCopy(nestedSize, nestedStrides, offsets, del) if err != nil { log.Fatal(err) } @@ -1897,7 +1945,7 @@ func(ts *Tensor) Must_NestedViewFromBufferCopy(nestedSize *Tensor, nestedStrides return retVal } -func(ts *Tensor) Must_NestedViewFromBufferCopyOut(out *Tensor, nestedSize *Tensor, nestedStrides *Tensor, offsets []int64, del bool)(retVal *Tensor) { +func(ts *Tensor) Must_NestedViewFromBufferCopyOut(out *Tensor, nestedSize *Tensor, nestedStrides *Tensor, offsets *Tensor, del bool)(retVal *Tensor) { retVal, err := ts._NestedViewFromBufferCopyOut(out, nestedSize, nestedStrides, offsets, del) if err != nil { log.Fatal(err) } @@ -2153,44 +2201,68 @@ func Must_SaturateWeightToFp16(weight *Tensor)(retVal *Tensor) { return retVal } -func Must_ScaledDotProductAttention(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, needAttnWeights bool, isCausal bool)(retVal0 *Tensor, retVal1 *Tensor) { +func Must_ScaledDotProductAttentionMath(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, dropoutMask *Tensor, scale []float64)(retVal0 *Tensor, retVal1 *Tensor) { - retVal0, retVal1, err := _ScaledDotProductAttention(query, key, value, attnMask, dropoutP, needAttnWeights, isCausal) + retVal0, retVal1, err := _ScaledDotProductAttentionMath(query, key, value, attnMask, dropoutP, isCausal, dropoutMask, scale) if err != nil { log.Fatal(err) } return retVal0, retVal1 } -func Must_ScaledDotProductAttentionMath(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, dropoutMask *Tensor)(retVal0 *Tensor, retVal1 *Tensor) { +func Must_ScaledDotProductEfficientAttention(query *Tensor, key *Tensor, value *Tensor, attnBias *Tensor, computeLogSumexp bool, dropoutP float64, isCausal bool, scale []float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor) { - retVal0, retVal1, err := _ScaledDotProductAttentionMath(query, key, value, attnMask, dropoutP, isCausal, dropoutMask) + retVal0, retVal1, retVal2, retVal3, err := _ScaledDotProductEfficientAttention(query, key, value, attnBias, computeLogSumexp, dropoutP, isCausal, scale) if err != nil { log.Fatal(err) } - return retVal0, retVal1 + return retVal0, retVal1, retVal2, retVal3 } -func Must_ScaledDotProductEfficientAttention(query *Tensor, key *Tensor, value *Tensor, computeLogSumexp bool, isCausal bool)(retVal0 *Tensor, retVal1 *Tensor) { +func Must_ScaledDotProductFlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed *Tensor, philoxOffset *Tensor, scale []float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { - retVal0, retVal1, err := _ScaledDotProductEfficientAttention(query, key, value, computeLogSumexp, isCausal) - if err != nil { log.Fatal(err) } - - return retVal0, retVal1 -} - -func Must_ScaledDotProductEfficientAttentionBackward(gradOut_ *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, isCausal bool, chunkGradOutputs bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { - - retVal0, retVal1, retVal2, err := _ScaledDotProductEfficientAttentionBackward(gradOut_, query, key, value, out, logsumexp, isCausal, chunkGradOutputs) + retVal0, retVal1, retVal2, err := _ScaledDotProductFlashAttentionBackward(gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, maxQ, maxK, dropoutP, isCausal, philoxSeed, philoxOffset, scale) if err != nil { log.Fatal(err) } return retVal0, retVal1, retVal2 } -func Must_ScaledDotProductFlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed int64, philoxOffset int64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { +func(ts *Tensor) Must_ScaledMm(mat2 *Tensor, bias *Tensor, outDtype gotch.DType, scaleA *Tensor, scaleB *Tensor, scaleResult *Tensor, del bool)(retVal0 *Tensor, retVal1 *Tensor) { - retVal0, retVal1, retVal2, err := _ScaledDotProductFlashAttentionBackward(gradOut, query, key, value, out, logsumexp, cumSeqQ, cumSeqK, maxQ, maxK, dropoutP, isCausal, philoxSeed, philoxOffset) + retVal0, retVal1, err := ts._ScaledMm(mat2, bias, outDtype, scaleA, scaleB, scaleResult, del) if err != nil { log.Fatal(err) } - return retVal0, retVal1, retVal2 + return retVal0, retVal1 +} + +func(ts *Tensor) Must_ScaledMmOut(out *Tensor, outAmax *Tensor, mat2 *Tensor, bias *Tensor, outDtype gotch.DType, scaleA *Tensor, scaleB *Tensor, scaleResult *Tensor, del bool)(retVal0 *Tensor, retVal1 *Tensor) { + + retVal0, retVal1, err := ts._ScaledMmOut(out, outAmax, mat2, bias, outDtype, scaleA, scaleB, scaleResult, del) + if err != nil { log.Fatal(err) } + + return retVal0, retVal1 +} + +func(ts *Tensor) Must_ScatterReduce(dim int64, index *Tensor, src *Tensor, reduce string, includeSelf bool, del bool)(retVal *Tensor) { + + retVal, err := ts._ScatterReduce(dim, index, src, reduce, includeSelf, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ScatterReduce_(dim int64, index *Tensor, src *Tensor, reduce string, includeSelf bool)() { + + err := ts._ScatterReduce_(dim, index, src, reduce, includeSelf) + if err != nil { log.Fatal(err) } + + return +} + +func(ts *Tensor) Must_ScatterReduceTwoOut(out *Tensor, dim int64, index *Tensor, src *Tensor, reduce string, includeSelf bool, del bool)(retVal *Tensor) { + + retVal, err := ts._ScatterReduceTwoOut(out, dim, index, src, reduce, includeSelf, del) + if err != nil { log.Fatal(err) } + + return retVal } func Must_SegmentReduceBackward(grad *Tensor, output *Tensor, data *Tensor, reduce string, lengths *Tensor, offsets *Tensor, axis int64, initial *Scalar)(retVal *Tensor) { @@ -2353,9 +2425,9 @@ func Must_SparseCompressedTensorUnsafe(compressedIndices *Tensor, plainIndices * return retVal } -func Must_SparseCooTensorUnsafe(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { +func Must_SparseCooTensorUnsafe(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor) { - retVal, err := _SparseCooTensorUnsafe(indices, values, size, optionsKind, optionsDevice) + retVal, err := _SparseCooTensorUnsafe(indices, values, size, optionsKind, optionsDevice, isCoalesced) if err != nil { log.Fatal(err) } return retVal @@ -2369,17 +2441,17 @@ func Must_SparseCooTensorWithDims(sparseDim int64, denseDim int64, size []int64, return retVal } -func Must_SparseCooTensorWithDimsAndTensors(sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { +func Must_SparseCooTensorWithDimsAndTensors(sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor) { - retVal, err := _SparseCooTensorWithDimsAndTensors(sparseDim, denseDim, size, indices, values, optionsKind, optionsDevice) + retVal, err := _SparseCooTensorWithDimsAndTensors(sparseDim, denseDim, size, indices, values, optionsKind, optionsDevice, isCoalesced) if err != nil { log.Fatal(err) } return retVal } -func Must_SparseCooTensorWithDimsAndTensorsOut(out *Tensor, sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor)(retVal *Tensor) { +func Must_SparseCooTensorWithDimsAndTensorsOut(out *Tensor, sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor, isCoalesced bool)(retVal *Tensor) { - retVal, err := _SparseCooTensorWithDimsAndTensorsOut(out, sparseDim, denseDim, size, indices, values) + retVal, err := _SparseCooTensorWithDimsAndTensorsOut(out, sparseDim, denseDim, size, indices, values, isCoalesced) if err != nil { log.Fatal(err) } return retVal @@ -2481,6 +2553,22 @@ func(ts *Tensor) Must_SparseLogSoftmaxOut(out *Tensor, dim int64, halfToFloat bo return retVal } +func(ts *Tensor) Must_SparseMaskProjection(mask *Tensor, accumulateMatches bool, del bool)(retVal *Tensor) { + + retVal, err := ts._SparseMaskProjection(mask, accumulateMatches, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_SparseMaskProjectionOut(out *Tensor, mask *Tensor, accumulateMatches bool, del bool)(retVal *Tensor) { + + retVal, err := ts._SparseMaskProjectionOut(out, mask, accumulateMatches, del) + if err != nil { log.Fatal(err) } + + return retVal +} + func Must_SparseMm(sparse *Tensor, dense *Tensor)(retVal *Tensor) { retVal, err := _SparseMm(sparse, dense) @@ -2505,6 +2593,14 @@ func(ts *Tensor) Must_SparseMmReduceImpl(other *Tensor, reduce string, del bool) return retVal0, retVal1 } +func Must_SparseSemiStructuredLinear(input *Tensor, weight *Tensor, meta *Tensor, bias *Tensor, activation string)(retVal *Tensor) { + + retVal, err := _SparseSemiStructuredLinear(input, weight, meta, bias, activation) + if err != nil { log.Fatal(err) } + + return retVal +} + func(ts *Tensor) Must_SparseSoftmax(dim int64, halfToFloat bool, del bool)(retVal *Tensor) { retVal, err := ts._SparseSoftmax(dim, halfToFloat, del) @@ -2753,6 +2849,22 @@ func(ts *Tensor) Must_TestCheckTensor(del bool)(retVal *Tensor) { return retVal } +func(ts *Tensor) Must_TestFunctorchFallback(other *Tensor, del bool)(retVal *Tensor) { + + retVal, err := ts._TestFunctorchFallback(other, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_TestFunctorchFallbackOut(out *Tensor, other *Tensor, del bool)(retVal *Tensor) { + + retVal, err := ts._TestFunctorchFallbackOut(out, other, del) + if err != nil { log.Fatal(err) } + + return retVal +} + func Must_TestOptionalFilledIntlist(values *Tensor, addends []int64)(retVal *Tensor) { retVal, err := _TestOptionalFilledIntlist(values, addends) @@ -2849,17 +2961,121 @@ func(ts *Tensor) Must_ToCopyOut(out *Tensor, nonBlocking bool, del bool)(retVal return retVal } -func(ts *Tensor) Must_ToDense(dtype gotch.DType, del bool)(retVal *Tensor) { +func(ts *Tensor) Must_ToDense(dtype gotch.DType, maskedGrad bool, del bool)(retVal *Tensor) { - retVal, err := ts._ToDense(dtype, del) + retVal, err := ts._ToDense(dtype, maskedGrad, del) if err != nil { log.Fatal(err) } return retVal } -func(ts *Tensor) Must_ToDenseOut(out *Tensor, dtype gotch.DType, del bool)(retVal *Tensor) { +func(ts *Tensor) Must_ToDenseOut(out *Tensor, dtype gotch.DType, maskedGrad bool, del bool)(retVal *Tensor) { - retVal, err := ts._ToDenseOut(out, dtype, del) + retVal, err := ts._ToDenseOut(out, dtype, maskedGrad, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparse(layout Layout, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparse(layout, blocksize, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseBsc(blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseBsc(blocksize, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseBscOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseBscOut(out, blocksize, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseBsr(blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseBsr(blocksize, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseBsrOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseBsrOut(out, blocksize, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseCsc(denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseCsc(denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseCscOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseCscOut(out, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseCsr(denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseCsr(denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseCsrOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseCsrOut(out, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseOut(out *Tensor, layout Layout, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseOut(out, layout, blocksize, denseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func Must_ToSparseSemiStructured(dense *Tensor)(retVal0 *Tensor, retVal1 *Tensor) { + + retVal0, retVal1, err := _ToSparseSemiStructured(dense) + if err != nil { log.Fatal(err) } + + return retVal0, retVal1 +} + +func(ts *Tensor) Must_ToSparseSparseDim(sparseDim int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseSparseDim(sparseDim, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_ToSparseSparseDimOut(out *Tensor, sparseDim int64, del bool)(retVal *Tensor) { + + retVal, err := ts._ToSparseSparseDimOut(out, sparseDim, del) if err != nil { log.Fatal(err) } return retVal @@ -2881,22 +3097,6 @@ func Must_TransformBiasRescaleQkvOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, q return retVal0, retVal1, retVal2 } -func Must_TransformerDecoderOnlyLayerFwd(src *Tensor, embedDim int64, numHeads int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, useGelu bool, normFirst bool, eps float64, normWeight1 *Tensor, normBias1 *Tensor, normWeight2 *Tensor, normBias2 *Tensor, ffnWeight1 *Tensor, ffnBias1 *Tensor, ffnWeight2 *Tensor, ffnBias2 *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { - - retVal0, retVal1, retVal2, err := _TransformerDecoderOnlyLayerFwd(src, embedDim, numHeads, qkvWeight, qkvBias, projWeight, projBias, useGelu, normFirst, eps, normWeight1, normBias1, normWeight2, normBias2, ffnWeight1, ffnBias1, ffnWeight2, ffnBias2, mask, incrKey, incrValue) - if err != nil { log.Fatal(err) } - - return retVal0, retVal1, retVal2 -} - -func Must_TransformerDecoderOnlyLayerFwdOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, src *Tensor, embedDim int64, numHeads int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, useGelu bool, normFirst bool, eps float64, normWeight1 *Tensor, normBias1 *Tensor, normWeight2 *Tensor, normBias2 *Tensor, ffnWeight1 *Tensor, ffnBias1 *Tensor, ffnWeight2 *Tensor, ffnBias2 *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor) { - - retVal0, retVal1, retVal2, err := _TransformerDecoderOnlyLayerFwdOut(out0, out1, out2, src, embedDim, numHeads, qkvWeight, qkvBias, projWeight, projBias, useGelu, normFirst, eps, normWeight1, normBias1, normWeight2, normBias2, ffnWeight1, ffnBias1, ffnWeight2, ffnBias2, mask, incrKey, incrValue) - if err != nil { log.Fatal(err) } - - return retVal0, retVal1, retVal2 -} - func Must_TransformerEncoderLayerFwd(src *Tensor, embedDim int64, numHeads int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, useGelu bool, normFirst bool, eps float64, normWeight1 *Tensor, normBias1 *Tensor, normWeight2 *Tensor, normBias2 *Tensor, ffnWeight1 *Tensor, ffnBias1 *Tensor, ffnWeight2 *Tensor, ffnBias2 *Tensor, mask *Tensor, maskType []int64)(retVal *Tensor) { retVal, err := _TransformerEncoderLayerFwd(src, embedDim, numHeads, qkvWeight, qkvBias, projWeight, projBias, useGelu, normFirst, eps, normWeight1, normBias1, normWeight2, normBias2, ffnWeight1, ffnBias1, ffnWeight2, ffnBias2, mask, maskType) @@ -3001,6 +3201,22 @@ func Must_UnpackDual(dual *Tensor, level int64)(retVal0 *Tensor, retVal1 *Tensor return retVal0, retVal1 } +func(ts *Tensor) Must_UnsafeIndex(indices []*Tensor, del bool)(retVal *Tensor) { + + retVal, err := ts._UnsafeIndex(indices, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) Must_UnsafeIndexPut(indices []*Tensor, values *Tensor, accumulate bool, del bool)(retVal *Tensor) { + + retVal, err := ts._UnsafeIndexPut(indices, values, accumulate, del) + if err != nil { log.Fatal(err) } + + return retVal +} + func(ts *Tensor) Must_UnsafeView(size []int64, del bool)(retVal *Tensor) { retVal, err := ts._UnsafeView(size, del) @@ -4529,17 +4745,17 @@ func MustBatchNorm(input *Tensor, weight *Tensor, bias *Tensor, runningMean *Ten return retVal } -func MustBatchNormBackwardElemt(gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, meanDy *Tensor, meanDyXmu *Tensor, count *Tensor)(retVal *Tensor) { +func MustBatchNormBackwardElemt(gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, sumDy *Tensor, sumDyXmu *Tensor, count *Tensor)(retVal *Tensor) { - retVal, err := BatchNormBackwardElemt(gradOut, input, mean, invstd, weight, meanDy, meanDyXmu, count) + retVal, err := BatchNormBackwardElemt(gradOut, input, mean, invstd, weight, sumDy, sumDyXmu, count) if err != nil { log.Fatal(err) } return retVal } -func MustBatchNormBackwardElemtOut(out *Tensor, gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, meanDy *Tensor, meanDyXmu *Tensor, count *Tensor)(retVal *Tensor) { +func MustBatchNormBackwardElemtOut(out *Tensor, gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, sumDy *Tensor, sumDyXmu *Tensor, count *Tensor)(retVal *Tensor) { - retVal, err := BatchNormBackwardElemtOut(out, gradOut, input, mean, invstd, weight, meanDy, meanDyXmu, count) + retVal, err := BatchNormBackwardElemtOut(out, gradOut, input, mean, invstd, weight, sumDy, sumDyXmu, count) if err != nil { log.Fatal(err) } return retVal @@ -7145,6 +7361,22 @@ func MustEmptyOut(out *Tensor, size []int64)(retVal *Tensor) { return retVal } +func MustEmptyPermuted(size []int64, physicalLayout []int64, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { + + retVal, err := EmptyPermuted(size, physicalLayout, optionsKind, optionsDevice) + if err != nil { log.Fatal(err) } + + return retVal +} + +func MustEmptyPermutedOut(out *Tensor, size []int64, physicalLayout []int64)(retVal *Tensor) { + + retVal, err := EmptyPermutedOut(out, size, physicalLayout) + if err != nil { log.Fatal(err) } + + return retVal +} + func MustEmptyQuantized(size []int64, qtensor *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { retVal, err := EmptyQuantized(size, qtensor, optionsKind, optionsDevice) @@ -12121,6 +12353,14 @@ func(ts *Tensor) MustMinOut(out *Tensor, other *Tensor, del bool)(retVal *Tensor return retVal } +func(ts *Tensor) MustMinUnaryOut(out *Tensor, del bool)(retVal *Tensor) { + + retVal, err := ts.MinUnaryOut(out, del) + if err != nil { log.Fatal(err) } + + return retVal +} + func(ts *Tensor) MustMinimum(other *Tensor, del bool)(retVal *Tensor) { retVal, err := ts.Minimum(other, del) @@ -13385,6 +13625,22 @@ func(ts *Tensor) MustNonzeroOut(out *Tensor, del bool)(retVal *Tensor) { return retVal } +func(ts *Tensor) MustNonzeroStatic(size int64, fillValue int64, del bool)(retVal *Tensor) { + + retVal, err := ts.NonzeroStatic(size, fillValue, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) MustNonzeroStaticOut(out *Tensor, size int64, fillValue int64, del bool)(retVal *Tensor) { + + retVal, err := ts.NonzeroStaticOut(out, size, fillValue, del) + if err != nil { log.Fatal(err) } + + return retVal +} + func(ts *Tensor) MustNorm(del bool)(retVal *Tensor) { retVal, err := ts.Norm(del) @@ -14177,6 +14433,22 @@ func(ts *Tensor) MustQuantizedMaxPool2dOut(out *Tensor, kernelSize []int64, stri return retVal } +func(ts *Tensor) MustQuantizedMaxPool3d(kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool, del bool)(retVal *Tensor) { + + retVal, err := ts.QuantizedMaxPool3d(kernelSize, stride, padding, dilation, ceilMode, del) + if err != nil { log.Fatal(err) } + + return retVal +} + +func(ts *Tensor) MustQuantizedMaxPool3dOut(out *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool, del bool)(retVal *Tensor) { + + retVal, err := ts.QuantizedMaxPool3dOut(out, kernelSize, stride, padding, dilation, ceilMode, del) + if err != nil { log.Fatal(err) } + + return retVal +} + func MustQuantizedRnnReluCell(input *Tensor, hx *Tensor, wIh *Tensor, wHh *Tensor, bIh *Tensor, bHh *Tensor, packedIh *Tensor, packedHh *Tensor, colOffsetsIh *Tensor, colOffsetsHh *Tensor, scaleIh *Scalar, scaleHh *Scalar, zeroPointIh *Scalar, zeroPointHh *Scalar)(retVal *Tensor) { retVal, err := QuantizedRnnReluCell(input, hx, wIh, wHh, bIh, bHh, packedIh, packedHh, colOffsetsIh, colOffsetsHh, scaleIh, scaleHh, zeroPointIh, zeroPointHh) @@ -15289,9 +15561,9 @@ func MustScalarTensorOut(out *Tensor, s *Scalar)(retVal *Tensor) { return retVal } -func MustScaledDotProductAttention(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool)(retVal *Tensor) { +func MustScaledDotProductAttention(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, scale []float64)(retVal *Tensor) { - retVal, err := ScaledDotProductAttention(query, key, value, attnMask, dropoutP, isCausal) + retVal, err := ScaledDotProductAttention(query, key, value, attnMask, dropoutP, isCausal, scale) if err != nil { log.Fatal(err) } return retVal @@ -16209,17 +16481,17 @@ func MustSparseCooTensor(size []int64, optionsKind gotch.DType, optionsDevice go return retVal } -func MustSparseCooTensorIndices(indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { +func MustSparseCooTensorIndices(indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor) { - retVal, err := SparseCooTensorIndices(indices, values, optionsKind, optionsDevice) + retVal, err := SparseCooTensorIndices(indices, values, optionsKind, optionsDevice, isCoalesced) if err != nil { log.Fatal(err) } return retVal } -func MustSparseCooTensorIndicesSize(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor) { +func MustSparseCooTensorIndicesSize(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor) { - retVal, err := SparseCooTensorIndicesSize(indices, values, size, optionsKind, optionsDevice) + retVal, err := SparseCooTensorIndicesSize(indices, values, size, optionsKind, optionsDevice, isCoalesced) if err != nil { log.Fatal(err) } return retVal @@ -17897,7 +18169,7 @@ func(ts *Tensor) MustStd(unbiased bool, del bool)(retVal *Tensor) { return retVal } -func(ts *Tensor) MustStdCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor) { +func(ts *Tensor) MustStdCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor) { retVal, err := ts.StdCorrection(dim, correction, keepdim, del) if err != nil { log.Fatal(err) } @@ -17905,7 +18177,7 @@ func(ts *Tensor) MustStdCorrection(dim []int64, correction []int64, keepdim bool return retVal } -func(ts *Tensor) MustStdCorrectionOut(out *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor) { +func(ts *Tensor) MustStdCorrectionOut(out *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor) { retVal, err := ts.StdCorrectionOut(out, dim, correction, keepdim, del) if err != nil { log.Fatal(err) } @@ -17929,7 +18201,7 @@ func(ts *Tensor) MustStdMean(unbiased bool, del bool)(retVal0 *Tensor, retVal1 * return retVal0, retVal1 } -func(ts *Tensor) MustStdMeanCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { +func(ts *Tensor) MustStdMeanCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := ts.StdMeanCorrection(dim, correction, keepdim, del) if err != nil { log.Fatal(err) } @@ -17937,7 +18209,7 @@ func(ts *Tensor) MustStdMeanCorrection(dim []int64, correction []int64, keepdim return retVal0, retVal1 } -func(ts *Tensor) MustStdMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { +func(ts *Tensor) MustStdMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := ts.StdMeanCorrectionOut(out0, out1, dim, correction, keepdim, del) if err != nil { log.Fatal(err) } @@ -18353,17 +18625,17 @@ func(ts *Tensor) MustTo(device gotch.Device, del bool)(retVal *Tensor) { return retVal } -func(ts *Tensor) MustToDense(dtype gotch.DType, del bool)(retVal *Tensor) { +func(ts *Tensor) MustToDense(dtype gotch.DType, maskedGrad bool, del bool)(retVal *Tensor) { - retVal, err := ts.ToDense(dtype, del) + retVal, err := ts.ToDense(dtype, maskedGrad, del) if err != nil { log.Fatal(err) } return retVal } -func MustToDenseBackward(grad *Tensor, input *Tensor)(retVal *Tensor) { +func MustToDenseBackward(grad *Tensor, input *Tensor, maskedGrad bool)(retVal *Tensor) { - retVal, err := ToDenseBackward(grad, input) + retVal, err := ToDenseBackward(grad, input, maskedGrad) if err != nil { log.Fatal(err) } return retVal @@ -18457,14 +18729,6 @@ func(ts *Tensor) MustToSparseBsc(blocksize []int64, denseDim []int64, del bool)( return retVal } -func(ts *Tensor) MustToSparseBscOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { - - retVal, err := ts.ToSparseBscOut(out, blocksize, denseDim, del) - if err != nil { log.Fatal(err) } - - return retVal -} - func(ts *Tensor) MustToSparseBsr(blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { retVal, err := ts.ToSparseBsr(blocksize, denseDim, del) @@ -18473,14 +18737,6 @@ func(ts *Tensor) MustToSparseBsr(blocksize []int64, denseDim []int64, del bool)( return retVal } -func(ts *Tensor) MustToSparseBsrOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { - - retVal, err := ts.ToSparseBsrOut(out, blocksize, denseDim, del) - if err != nil { log.Fatal(err) } - - return retVal -} - func(ts *Tensor) MustToSparseCsc(denseDim []int64, del bool)(retVal *Tensor) { retVal, err := ts.ToSparseCsc(denseDim, del) @@ -18489,14 +18745,6 @@ func(ts *Tensor) MustToSparseCsc(denseDim []int64, del bool)(retVal *Tensor) { return retVal } -func(ts *Tensor) MustToSparseCscOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor) { - - retVal, err := ts.ToSparseCscOut(out, denseDim, del) - if err != nil { log.Fatal(err) } - - return retVal -} - func(ts *Tensor) MustToSparseCsr(denseDim []int64, del bool)(retVal *Tensor) { retVal, err := ts.ToSparseCsr(denseDim, del) @@ -18505,22 +18753,6 @@ func(ts *Tensor) MustToSparseCsr(denseDim []int64, del bool)(retVal *Tensor) { return retVal } -func(ts *Tensor) MustToSparseCsrOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor) { - - retVal, err := ts.ToSparseCsrOut(out, denseDim, del) - if err != nil { log.Fatal(err) } - - return retVal -} - -func(ts *Tensor) MustToSparseOut(out *Tensor, layout Layout, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor) { - - retVal, err := ts.ToSparseOut(out, layout, blocksize, denseDim, del) - if err != nil { log.Fatal(err) } - - return retVal -} - func(ts *Tensor) MustToSparseSparseDim(sparseDim int64, del bool)(retVal *Tensor) { retVal, err := ts.ToSparseSparseDim(sparseDim, del) @@ -18529,14 +18761,6 @@ func(ts *Tensor) MustToSparseSparseDim(sparseDim int64, del bool)(retVal *Tensor return retVal } -func(ts *Tensor) MustToSparseSparseDimOut(out *Tensor, sparseDim int64, del bool)(retVal *Tensor) { - - retVal, err := ts.ToSparseSparseDimOut(out, sparseDim, del) - if err != nil { log.Fatal(err) } - - return retVal -} - func(ts *Tensor) MustTopk(k int64, dim int64, largest bool, sorted bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := ts.Topk(k, dim, largest, sorted, del) @@ -19305,7 +19529,7 @@ func(ts *Tensor) MustVar(unbiased bool, del bool)(retVal *Tensor) { return retVal } -func(ts *Tensor) MustVarCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor) { +func(ts *Tensor) MustVarCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor) { retVal, err := ts.VarCorrection(dim, correction, keepdim, del) if err != nil { log.Fatal(err) } @@ -19313,7 +19537,7 @@ func(ts *Tensor) MustVarCorrection(dim []int64, correction []int64, keepdim bool return retVal } -func(ts *Tensor) MustVarCorrectionOut(out *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor) { +func(ts *Tensor) MustVarCorrectionOut(out *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor) { retVal, err := ts.VarCorrectionOut(out, dim, correction, keepdim, del) if err != nil { log.Fatal(err) } @@ -19337,7 +19561,7 @@ func(ts *Tensor) MustVarMean(unbiased bool, del bool)(retVal0 *Tensor, retVal1 * return retVal0, retVal1 } -func(ts *Tensor) MustVarMeanCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { +func(ts *Tensor) MustVarMeanCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := ts.VarMeanCorrection(dim, correction, keepdim, del) if err != nil { log.Fatal(err) } @@ -19345,7 +19569,7 @@ func(ts *Tensor) MustVarMeanCorrection(dim []int64, correction []int64, keepdim return retVal0, retVal1 } -func(ts *Tensor) MustVarMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { +func(ts *Tensor) MustVarMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor) { retVal0, retVal1, err := ts.VarMeanCorrectionOut(out0, out1, dim, correction, keepdim, del) if err != nil { log.Fatal(err) } diff --git a/ts/tensor-generated.go b/ts/tensor-generated.go index d13aea0..0077169 100644 --- a/ts/tensor-generated.go +++ b/ts/tensor-generated.go @@ -1088,20 +1088,6 @@ func(ts *Tensor) _CholeskySolveHelperOut(out *Tensor, a *Tensor, upper bool, del return retVal, err } -// func.returns = `bool`: -// -------------------------- -func _ChunkGradOutputsEfficientAttention(query *Tensor, key *Tensor, value *Tensor, isCausal bool)(retVal bool, err error) { - - cisCausal := int32(0) - if isCausal { cisCausal = int32(1) } - retVal = lib.Atg_ChunkGradOutputsEfficientAttention(query.ctensor, key.ctensor, value.ctensor, cisCausal) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_ChunkGradOutputsEfficientAttention() failed: %w", err) - return retVal, err - } - return retVal, err -} - // func.returns = `fixed 1`: // -------------------------- @@ -1607,6 +1593,40 @@ func(ts *Tensor) _CopyFromOut(out *Tensor, dst *Tensor, nonBlocking bool, del bo return retVal, err } +// func.returns = `fixed 1`: +// -------------------------- + +func _CsltCompress(input *Tensor)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_CsltCompress(ptr, input.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_CsltCompress() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_CsltCompress") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func _CsltSparseMm(compressedA *Tensor, denseB *Tensor, bias *Tensor, transposeResult bool)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + ctransposeResult := int32(0) + if transposeResult { ctransposeResult = int32(1) } + lib.Atg_CsltSparseMm(ptr, compressedA.ctensor, denseB.ctensor, bias.ctensor, ctransposeResult) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_CsltSparseMm() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_CsltSparseMm") + + return retVal, err +} + // func.returns = `fixed ntensors`: // --------------------------------- func _CtcLoss(logProbs *Tensor, targets *Tensor, inputLengths []int64, targetLengths []int64, blank int64, zeroInfinity bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { @@ -1956,30 +1976,6 @@ batchSizesLen := len(batchSizes) return retVal0, retVal1, retVal2, retVal3, retVal4, err } -// func.returns = `int64`: -// -------------------------- -func _CufftGetPlanCacheMaxSize(deviceIndex int64)(retVal int64, err error) { - - retVal = lib.Atg_CufftGetPlanCacheMaxSize(deviceIndex) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_CufftGetPlanCacheMaxSize() failed: %w", err) - return retVal, err - } - return retVal, err -} - -// func.returns = `int64`: -// -------------------------- -func _CufftGetPlanCacheSize(deviceIndex int64)(retVal int64, err error) { - - retVal = lib.Atg_CufftGetPlanCacheSize(deviceIndex) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_CufftGetPlanCacheSize() failed: %w", err) - return retVal, err - } - return retVal, err -} - // func.returns = `int64`: // -------------------------- func(ts *Tensor) _DebugHasInternalOverlap(del bool)(retVal int64, err error) { @@ -2069,25 +2065,37 @@ func _DirichletGradOut(out *Tensor, x *Tensor, alpha *Tensor, total *Tensor)(ret // func.returns = `fixed ntensors`: // --------------------------------- -func _EfficientAttentionBackward(gradOut_ *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, isCausal bool, chunkGradOutputs bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { +func _EfficientAttentionBackward(gradOut_ *Tensor, query *Tensor, key *Tensor, value *Tensor, bias *Tensor, out *Tensor, cuSeqlensQ *Tensor, cuSeqlensK *Tensor, maxSeqlenK int64, maxSeqlenQ int64, logsumexp *Tensor, dropoutP float64, philoxSeed *Tensor, philoxOffset *Tensor, customMaskType int64, biasRequiresGrad bool, scale []float64, numSplitsKey []int64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor, err error) { ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) + ctensorPtr3 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr2)) + unsafe.Sizeof(ctensorPtr0))) - cisCausal := int32(0) - if isCausal { cisCausal = int32(1) } -cchunkGradOutputs := int32(0) - if chunkGradOutputs { cchunkGradOutputs = int32(1) } - lib.Atg_EfficientAttentionBackward(ctensorPtr0, gradOut_.ctensor, query.ctensor, key.ctensor, value.ctensor, out.ctensor, logsumexp.ctensor, cisCausal, cchunkGradOutputs) + cbiasRequiresGrad := int32(0) + if biasRequiresGrad { cbiasRequiresGrad = int32(1) } +var cscaleVal float64 = 0.0 + var cscaleNull int = 1 + if len(scale) > 0 { + cscaleVal = scale[0] + cscaleNull = 0 + } +var cnumSplitsKeyVal int64 = 0 + var cnumSplitsKeyNull int = 1 + if len(numSplitsKey) > 0 { + cnumSplitsKeyVal = numSplitsKey[0] + cnumSplitsKeyNull = 0 + } + lib.Atg_EfficientAttentionBackward(ctensorPtr0, gradOut_.ctensor, query.ctensor, key.ctensor, value.ctensor, bias.ctensor, out.ctensor, cuSeqlensQ.ctensor, cuSeqlensK.ctensor, maxSeqlenK, maxSeqlenQ, logsumexp.ctensor, dropoutP, philoxSeed.ctensor, philoxOffset.ctensor, customMaskType, cbiasRequiresGrad, cscaleVal, cscaleNull, cnumSplitsKeyVal, cnumSplitsKeyNull) if err = TorchErr(); err != nil { err = fmt.Errorf("_EfficientAttentionBackward() failed: %w", err) - return retVal0, retVal1, retVal2, err + return retVal0, retVal1, retVal2, retVal3, err } retVal0 = newTensor(*ctensorPtr0, "_EfficientAttentionBackward_0") retVal1 = newTensor(*ctensorPtr1, "_EfficientAttentionBackward_1") retVal2 = newTensor(*ctensorPtr2, "_EfficientAttentionBackward_2") + retVal3 = newTensor(*ctensorPtr3, "_EfficientAttentionBackward_3") - return retVal0, retVal1, retVal2, err + return retVal0, retVal1, retVal2, retVal3, err } // func.returns = `fixed 1`: @@ -2698,16 +2706,38 @@ conesided := int32(0) return retVal, err } +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _FillMemEffDropoutMask_(dropoutP float64, seed int64, offset int64)(err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_FillMemEffDropoutMask_(ptr, ts.ctensor, dropoutP, seed, offset) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_FillMemEffDropoutMask_() failed: %w", err) + return err + } + ts.ctensor = *ptr + + return err +} + // func.returns = `fixed ntensors`: // --------------------------------- -func _FlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed int64, philoxOffset int64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { +func _FlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed *Tensor, philoxOffset *Tensor, scale []float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) cisCausal := int32(0) if isCausal { cisCausal = int32(1) } - lib.Atg_FlashAttentionBackward(ctensorPtr0, gradOut.ctensor, query.ctensor, key.ctensor, value.ctensor, out.ctensor, logsumexp.ctensor, cumSeqQ.ctensor, cumSeqK.ctensor, maxQ, maxK, dropoutP, cisCausal, philoxSeed, philoxOffset) +var cscaleVal float64 = 0.0 + var cscaleNull int = 1 + if len(scale) > 0 { + cscaleVal = scale[0] + cscaleNull = 0 + } + lib.Atg_FlashAttentionBackward(ctensorPtr0, gradOut.ctensor, query.ctensor, key.ctensor, value.ctensor, out.ctensor, logsumexp.ctensor, cumSeqQ.ctensor, cumSeqK.ctensor, maxQ, maxK, dropoutP, cisCausal, philoxSeed.ctensor, philoxOffset.ctensor, cscaleVal, cscaleNull) if err = TorchErr(); err != nil { err = fmt.Errorf("_FlashAttentionBackward() failed: %w", err) return retVal0, retVal1, retVal2, err @@ -2765,6 +2795,79 @@ carg3 := int32(0) return retVal, err } +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _FunctionalAssertAsync(assertMsg string, depToken *Tensor, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_FunctionalAssertAsync(ptr, ts.ctensor, assertMsg, depToken.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_FunctionalAssertAsync() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_FunctionalAssertAsync") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func _FunctionalSymConstrainRange(size *Scalar, min []int64, max []int64, depToken *Tensor)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cminVal int64 = 0 + var cminNull int = 1 + if len(min) > 0 { + cminVal = min[0] + cminNull = 0 + } +var cmaxVal int64 = 0 + var cmaxNull int = 1 + if len(max) > 0 { + cmaxVal = max[0] + cmaxNull = 0 + } + lib.Atg_FunctionalSymConstrainRange(ptr, size.cscalar, cminVal, cminNull, cmaxVal, cmaxNull, depToken.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_FunctionalSymConstrainRange() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_FunctionalSymConstrainRange") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func _FunctionalSymConstrainRangeForSize(size *Scalar, min []int64, max []int64, depToken *Tensor)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cminVal int64 = 0 + var cminNull int = 1 + if len(min) > 0 { + cminVal = min[0] + cminNull = 0 + } +var cmaxVal int64 = 0 + var cmaxNull int = 1 + if len(max) > 0 { + cmaxVal = max[0] + cmaxNull = 0 + } + lib.Atg_FunctionalSymConstrainRangeForSize(ptr, size.cscalar, cminVal, cminNull, cmaxVal, cmaxNull, depToken.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_FunctionalSymConstrainRangeForSize() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_FunctionalSymConstrainRangeForSize") + + return retVal, err +} + // func.returns = `fixed ntensors`: // --------------------------------- func(ts *Tensor) _FusedDropout(p float64, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { @@ -2877,11 +2980,17 @@ csymmetricQuant := int32(0) // func.returns = `int64`: // -------------------------- -func _FusedSdpChoice(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool)(retVal int64, err error) { +func _FusedSdpChoice(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, scale []float64)(retVal int64, err error) { cisCausal := int32(0) if isCausal { cisCausal = int32(1) } - retVal = lib.Atg_FusedSdpChoice(query.ctensor, key.ctensor, value.ctensor, attnMask.ctensor, dropoutP, cisCausal) +var cscaleVal float64 = 0.0 + var cscaleNull int = 1 + if len(scale) > 0 { + cscaleVal = scale[0] + cscaleNull = 0 + } + retVal = lib.Atg_FusedSdpChoice(query.ctensor, key.ctensor, value.ctensor, attnMask.ctensor, dropoutP, cisCausal, cscaleVal, cscaleNull) if err = TorchErr(); err != nil { err = fmt.Errorf("_FusedSdpChoice() failed: %w", err) return retVal, err @@ -3201,6 +3310,40 @@ func(ts *Tensor) _IndicesCopyOut(out *Tensor, del bool)(retVal *Tensor, err erro // func.returns = `fixed 1`: // -------------------------- +func(ts *Tensor) _IntMm(mat2 *Tensor, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_IntMm(ptr, ts.ctensor, mat2.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_IntMm() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_IntMm") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _IntMmOut(out *Tensor, mat2 *Tensor, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_IntMmOut(ptr, out.ctensor, ts.ctensor, mat2.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_IntMmOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_IntMmOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func(ts *Tensor) _IsAllTrue(del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -3664,6 +3807,22 @@ ccheckErrors := int32(0) // func.returns = `fixed 1`: // -------------------------- +func _MakeDepToken(optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_MakeDepToken(ptr, optionsKind.CInt(), optionsDevice.CInt()) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_MakeDepToken() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_MakeDepToken") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func _MakeDual(primal *Tensor, tangent *Tensor, level int64)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -4169,6 +4328,44 @@ func _NativeBatchNormLegitNoStatsOut(out *Tensor, saveMean *Tensor, saveInvstd * return retVal0, retVal1, retVal2, err } +// func.returns = `fixed ntensors`: +// --------------------------------- +func _NativeBatchNormLegitNoTraining(input *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, momentum float64, eps float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { + ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) + ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) + + lib.Atg_NativeBatchNormLegitNoTraining(ctensorPtr0, input.ctensor, weight.ctensor, bias.ctensor, runningMean.ctensor, runningVar.ctensor, momentum, eps) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_NativeBatchNormLegitNoTraining() failed: %w", err) + return retVal0, retVal1, retVal2, err + } + retVal0 = newTensor(*ctensorPtr0, "_NativeBatchNormLegitNoTraining_0") + retVal1 = newTensor(*ctensorPtr1, "_NativeBatchNormLegitNoTraining_1") + retVal2 = newTensor(*ctensorPtr2, "_NativeBatchNormLegitNoTraining_2") + + return retVal0, retVal1, retVal2, err +} + +// func.returns = `fixed ntensors`: +// --------------------------------- +func _NativeBatchNormLegitNoTrainingOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, input *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, momentum float64, eps float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { + ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) + ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) + + lib.Atg_NativeBatchNormLegitNoTrainingOut(ctensorPtr0, out0.ctensor, out1.ctensor, out2.ctensor, input.ctensor, weight.ctensor, bias.ctensor, runningMean.ctensor, runningVar.ctensor, momentum, eps) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_NativeBatchNormLegitNoTrainingOut() failed: %w", err) + return retVal0, retVal1, retVal2, err + } + retVal0 = newTensor(*ctensorPtr0, "_NativeBatchNormLegitNoTrainingOut_0") + retVal1 = newTensor(*ctensorPtr1, "_NativeBatchNormLegitNoTrainingOut_1") + retVal2 = newTensor(*ctensorPtr2, "_NativeBatchNormLegitNoTrainingOut_2") + + return retVal0, retVal1, retVal2, err +} + // func.returns = `fixed ntensors`: // --------------------------------- func _NativeBatchNormLegitOut(out *Tensor, saveMean *Tensor, saveInvstd *Tensor, input *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, training bool, momentum float64, eps float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { @@ -4190,56 +4387,6 @@ func _NativeBatchNormLegitOut(out *Tensor, saveMean *Tensor, saveInvstd *Tensor, return retVal0, retVal1, retVal2, err } -// func.returns = `fixed ntensors`: -// --------------------------------- -func _NativeDecoderOnlyMultiHeadAttention(query *Tensor, key *Tensor, value *Tensor, embedDim int64, numHead int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor, needWeights bool, averageAttnWeights bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor, err error) { - ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) - ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) - ctensorPtr3 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr2)) + unsafe.Sizeof(ctensorPtr0))) - - cneedWeights := int32(0) - if needWeights { cneedWeights = int32(1) } -caverageAttnWeights := int32(0) - if averageAttnWeights { caverageAttnWeights = int32(1) } - lib.Atg_NativeDecoderOnlyMultiHeadAttention(ctensorPtr0, query.ctensor, key.ctensor, value.ctensor, embedDim, numHead, qkvWeight.ctensor, qkvBias.ctensor, projWeight.ctensor, projBias.ctensor, mask.ctensor, incrKey.ctensor, incrValue.ctensor, cneedWeights, caverageAttnWeights) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_NativeDecoderOnlyMultiHeadAttention() failed: %w", err) - return retVal0, retVal1, retVal2, retVal3, err - } - retVal0 = newTensor(*ctensorPtr0, "_NativeDecoderOnlyMultiHeadAttention_0") - retVal1 = newTensor(*ctensorPtr1, "_NativeDecoderOnlyMultiHeadAttention_1") - retVal2 = newTensor(*ctensorPtr2, "_NativeDecoderOnlyMultiHeadAttention_2") - retVal3 = newTensor(*ctensorPtr3, "_NativeDecoderOnlyMultiHeadAttention_3") - - return retVal0, retVal1, retVal2, retVal3, err -} - -// func.returns = `fixed ntensors`: -// --------------------------------- -func _NativeDecoderOnlyMultiHeadAttentionOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, out3 *Tensor, query *Tensor, key *Tensor, value *Tensor, embedDim int64, numHead int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor, needWeights bool, averageAttnWeights bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor, err error) { - ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) - ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) - ctensorPtr3 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr2)) + unsafe.Sizeof(ctensorPtr0))) - - cneedWeights := int32(0) - if needWeights { cneedWeights = int32(1) } -caverageAttnWeights := int32(0) - if averageAttnWeights { caverageAttnWeights = int32(1) } - lib.Atg_NativeDecoderOnlyMultiHeadAttentionOut(ctensorPtr0, out0.ctensor, out1.ctensor, out2.ctensor, out3.ctensor, query.ctensor, key.ctensor, value.ctensor, embedDim, numHead, qkvWeight.ctensor, qkvBias.ctensor, projWeight.ctensor, projBias.ctensor, mask.ctensor, incrKey.ctensor, incrValue.ctensor, cneedWeights, caverageAttnWeights) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_NativeDecoderOnlyMultiHeadAttentionOut() failed: %w", err) - return retVal0, retVal1, retVal2, retVal3, err - } - retVal0 = newTensor(*ctensorPtr0, "_NativeDecoderOnlyMultiHeadAttentionOut_0") - retVal1 = newTensor(*ctensorPtr1, "_NativeDecoderOnlyMultiHeadAttentionOut_1") - retVal2 = newTensor(*ctensorPtr2, "_NativeDecoderOnlyMultiHeadAttentionOut_2") - retVal3 = newTensor(*ctensorPtr3, "_NativeDecoderOnlyMultiHeadAttentionOut_3") - - return retVal0, retVal1, retVal2, retVal3, err -} - // func.returns = `fixed ntensors`: // --------------------------------- func _NativeMultiHeadAttention(query *Tensor, key *Tensor, value *Tensor, embedDim int64, numHead int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, mask *Tensor, needWeights bool, averageAttnWeights bool, maskType []int64)(retVal0 *Tensor, retVal1 *Tensor, err error) { @@ -4453,12 +4600,11 @@ ckeepdim := int32(0) // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) _NestedViewFromBuffer(nestedSize *Tensor, nestedStrides *Tensor, offsets []int64, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) _NestedViewFromBuffer(nestedSize *Tensor, nestedStrides *Tensor, offsets *Tensor, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - offsetsLen := len(offsets) - lib.Atg_NestedViewFromBuffer(ptr, ts.ctensor, nestedSize.ctensor, nestedStrides.ctensor, offsets, offsetsLen) + lib.Atg_NestedViewFromBuffer(ptr, ts.ctensor, nestedSize.ctensor, nestedStrides.ctensor, offsets.ctensor) if err = TorchErr(); err != nil { err = fmt.Errorf("_NestedViewFromBuffer() failed: %w", err) return retVal, err @@ -4471,12 +4617,11 @@ func(ts *Tensor) _NestedViewFromBuffer(nestedSize *Tensor, nestedStrides *Tensor // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) _NestedViewFromBufferCopy(nestedSize *Tensor, nestedStrides *Tensor, offsets []int64, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) _NestedViewFromBufferCopy(nestedSize *Tensor, nestedStrides *Tensor, offsets *Tensor, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - offsetsLen := len(offsets) - lib.Atg_NestedViewFromBufferCopy(ptr, ts.ctensor, nestedSize.ctensor, nestedStrides.ctensor, offsets, offsetsLen) + lib.Atg_NestedViewFromBufferCopy(ptr, ts.ctensor, nestedSize.ctensor, nestedStrides.ctensor, offsets.ctensor) if err = TorchErr(); err != nil { err = fmt.Errorf("_NestedViewFromBufferCopy() failed: %w", err) return retVal, err @@ -4489,12 +4634,11 @@ func(ts *Tensor) _NestedViewFromBufferCopy(nestedSize *Tensor, nestedStrides *Te // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) _NestedViewFromBufferCopyOut(out *Tensor, nestedSize *Tensor, nestedStrides *Tensor, offsets []int64, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) _NestedViewFromBufferCopyOut(out *Tensor, nestedSize *Tensor, nestedStrides *Tensor, offsets *Tensor, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - offsetsLen := len(offsets) - lib.Atg_NestedViewFromBufferCopyOut(ptr, out.ctensor, ts.ctensor, nestedSize.ctensor, nestedStrides.ctensor, offsets, offsetsLen) + lib.Atg_NestedViewFromBufferCopyOut(ptr, out.ctensor, ts.ctensor, nestedSize.ctensor, nestedStrides.ctensor, offsets.ctensor) if err = TorchErr(); err != nil { err = fmt.Errorf("_NestedViewFromBufferCopyOut() failed: %w", err) return retVal, err @@ -5051,34 +5195,19 @@ func _SaturateWeightToFp16(weight *Tensor)(retVal *Tensor, err error) { // func.returns = `fixed ntensors`: // --------------------------------- -func _ScaledDotProductAttention(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, needAttnWeights bool, isCausal bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { - ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) - - cneedAttnWeights := int32(0) - if needAttnWeights { cneedAttnWeights = int32(1) } -cisCausal := int32(0) - if isCausal { cisCausal = int32(1) } - lib.Atg_ScaledDotProductAttention(ctensorPtr0, query.ctensor, key.ctensor, value.ctensor, attnMask.ctensor, dropoutP, cneedAttnWeights, cisCausal) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_ScaledDotProductAttention() failed: %w", err) - return retVal0, retVal1, err - } - retVal0 = newTensor(*ctensorPtr0, "_ScaledDotProductAttention_0") - retVal1 = newTensor(*ctensorPtr1, "_ScaledDotProductAttention_1") - - return retVal0, retVal1, err -} - -// func.returns = `fixed ntensors`: -// --------------------------------- -func _ScaledDotProductAttentionMath(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, dropoutMask *Tensor)(retVal0 *Tensor, retVal1 *Tensor, err error) { +func _ScaledDotProductAttentionMath(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, dropoutMask *Tensor, scale []float64)(retVal0 *Tensor, retVal1 *Tensor, err error) { ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) cisCausal := int32(0) if isCausal { cisCausal = int32(1) } - lib.Atg_ScaledDotProductAttentionMath(ctensorPtr0, query.ctensor, key.ctensor, value.ctensor, attnMask.ctensor, dropoutP, cisCausal, dropoutMask.ctensor) +var cscaleVal float64 = 0.0 + var cscaleNull int = 1 + if len(scale) > 0 { + cscaleVal = scale[0] + cscaleNull = 0 + } + lib.Atg_ScaledDotProductAttentionMath(ctensorPtr0, query.ctensor, key.ctensor, value.ctensor, attnMask.ctensor, dropoutP, cisCausal, dropoutMask.ctensor, cscaleVal, cscaleNull) if err = TorchErr(); err != nil { err = fmt.Errorf("_ScaledDotProductAttentionMath() failed: %w", err) return retVal0, retVal1, err @@ -5091,58 +5220,51 @@ func _ScaledDotProductAttentionMath(query *Tensor, key *Tensor, value *Tensor, a // func.returns = `fixed ntensors`: // --------------------------------- -func _ScaledDotProductEfficientAttention(query *Tensor, key *Tensor, value *Tensor, computeLogSumexp bool, isCausal bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { +func _ScaledDotProductEfficientAttention(query *Tensor, key *Tensor, value *Tensor, attnBias *Tensor, computeLogSumexp bool, dropoutP float64, isCausal bool, scale []float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, retVal3 *Tensor, err error) { ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) + ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) + ctensorPtr3 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr2)) + unsafe.Sizeof(ctensorPtr0))) ccomputeLogSumexp := int32(0) if computeLogSumexp { ccomputeLogSumexp = int32(1) } cisCausal := int32(0) if isCausal { cisCausal = int32(1) } - lib.Atg_ScaledDotProductEfficientAttention(ctensorPtr0, query.ctensor, key.ctensor, value.ctensor, ccomputeLogSumexp, cisCausal) +var cscaleVal float64 = 0.0 + var cscaleNull int = 1 + if len(scale) > 0 { + cscaleVal = scale[0] + cscaleNull = 0 + } + lib.Atg_ScaledDotProductEfficientAttention(ctensorPtr0, query.ctensor, key.ctensor, value.ctensor, attnBias.ctensor, ccomputeLogSumexp, dropoutP, cisCausal, cscaleVal, cscaleNull) if err = TorchErr(); err != nil { err = fmt.Errorf("_ScaledDotProductEfficientAttention() failed: %w", err) - return retVal0, retVal1, err + return retVal0, retVal1, retVal2, retVal3, err } retVal0 = newTensor(*ctensorPtr0, "_ScaledDotProductEfficientAttention_0") retVal1 = newTensor(*ctensorPtr1, "_ScaledDotProductEfficientAttention_1") + retVal2 = newTensor(*ctensorPtr2, "_ScaledDotProductEfficientAttention_2") + retVal3 = newTensor(*ctensorPtr3, "_ScaledDotProductEfficientAttention_3") - return retVal0, retVal1, err + return retVal0, retVal1, retVal2, retVal3, err } // func.returns = `fixed ntensors`: // --------------------------------- -func _ScaledDotProductEfficientAttentionBackward(gradOut_ *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, isCausal bool, chunkGradOutputs bool)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { +func _ScaledDotProductFlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed *Tensor, philoxOffset *Tensor, scale []float64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) cisCausal := int32(0) if isCausal { cisCausal = int32(1) } -cchunkGradOutputs := int32(0) - if chunkGradOutputs { cchunkGradOutputs = int32(1) } - lib.Atg_ScaledDotProductEfficientAttentionBackward(ctensorPtr0, gradOut_.ctensor, query.ctensor, key.ctensor, value.ctensor, out.ctensor, logsumexp.ctensor, cisCausal, cchunkGradOutputs) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_ScaledDotProductEfficientAttentionBackward() failed: %w", err) - return retVal0, retVal1, retVal2, err - } - retVal0 = newTensor(*ctensorPtr0, "_ScaledDotProductEfficientAttentionBackward_0") - retVal1 = newTensor(*ctensorPtr1, "_ScaledDotProductEfficientAttentionBackward_1") - retVal2 = newTensor(*ctensorPtr2, "_ScaledDotProductEfficientAttentionBackward_2") - - return retVal0, retVal1, retVal2, err -} - -// func.returns = `fixed ntensors`: -// --------------------------------- -func _ScaledDotProductFlashAttentionBackward(gradOut *Tensor, query *Tensor, key *Tensor, value *Tensor, out *Tensor, logsumexp *Tensor, cumSeqQ *Tensor, cumSeqK *Tensor, maxQ int64, maxK int64, dropoutP float64, isCausal bool, philoxSeed int64, philoxOffset int64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { - ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) - ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) - - cisCausal := int32(0) - if isCausal { cisCausal = int32(1) } - lib.Atg_ScaledDotProductFlashAttentionBackward(ctensorPtr0, gradOut.ctensor, query.ctensor, key.ctensor, value.ctensor, out.ctensor, logsumexp.ctensor, cumSeqQ.ctensor, cumSeqK.ctensor, maxQ, maxK, dropoutP, cisCausal, philoxSeed, philoxOffset) +var cscaleVal float64 = 0.0 + var cscaleNull int = 1 + if len(scale) > 0 { + cscaleVal = scale[0] + cscaleNull = 0 + } + lib.Atg_ScaledDotProductFlashAttentionBackward(ctensorPtr0, gradOut.ctensor, query.ctensor, key.ctensor, value.ctensor, out.ctensor, logsumexp.ctensor, cumSeqQ.ctensor, cumSeqK.ctensor, maxQ, maxK, dropoutP, cisCausal, philoxSeed.ctensor, philoxOffset.ctensor, cscaleVal, cscaleNull) if err = TorchErr(); err != nil { err = fmt.Errorf("_ScaledDotProductFlashAttentionBackward() failed: %w", err) return retVal0, retVal1, retVal2, err @@ -5154,6 +5276,98 @@ func _ScaledDotProductFlashAttentionBackward(gradOut *Tensor, query *Tensor, key return retVal0, retVal1, retVal2, err } +// func.returns = `fixed ntensors`: +// --------------------------------- +func(ts *Tensor) _ScaledMm(mat2 *Tensor, bias *Tensor, outDtype gotch.DType, scaleA *Tensor, scaleB *Tensor, scaleResult *Tensor, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { + if del { defer ts.MustDrop() } + ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) + + lib.Atg_ScaledMm(ctensorPtr0, ts.ctensor, mat2.ctensor, bias.ctensor, outDtype.CInt(), scaleA.ctensor, scaleB.ctensor, scaleResult.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ScaledMm() failed: %w", err) + return retVal0, retVal1, err + } + retVal0 = newTensor(*ctensorPtr0, "_ScaledMm_0") + retVal1 = newTensor(*ctensorPtr1, "_ScaledMm_1") + + return retVal0, retVal1, err +} + +// func.returns = `fixed ntensors`: +// --------------------------------- +func(ts *Tensor) _ScaledMmOut(out *Tensor, outAmax *Tensor, mat2 *Tensor, bias *Tensor, outDtype gotch.DType, scaleA *Tensor, scaleB *Tensor, scaleResult *Tensor, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { + if del { defer ts.MustDrop() } + ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) + + lib.Atg_ScaledMmOut(ctensorPtr0, out.ctensor, outAmax.ctensor, ts.ctensor, mat2.ctensor, bias.ctensor, outDtype.CInt(), scaleA.ctensor, scaleB.ctensor, scaleResult.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ScaledMmOut() failed: %w", err) + return retVal0, retVal1, err + } + retVal0 = newTensor(*ctensorPtr0, "_ScaledMmOut_0") + retVal1 = newTensor(*ctensorPtr1, "_ScaledMmOut_1") + + return retVal0, retVal1, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ScatterReduce(dim int64, index *Tensor, src *Tensor, reduce string, includeSelf bool, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + cincludeSelf := int32(0) + if includeSelf { cincludeSelf = int32(1) } + lib.Atg_ScatterReduce(ptr, ts.ctensor, dim, index.ctensor, src.ctensor, reduce, cincludeSelf) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ScatterReduce() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ScatterReduce") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ScatterReduce_(dim int64, index *Tensor, src *Tensor, reduce string, includeSelf bool)(err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + cincludeSelf := int32(0) + if includeSelf { cincludeSelf = int32(1) } + lib.Atg_ScatterReduce_(ptr, ts.ctensor, dim, index.ctensor, src.ctensor, reduce, cincludeSelf) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ScatterReduce_() failed: %w", err) + return err + } + ts.ctensor = *ptr + + return err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ScatterReduceTwoOut(out *Tensor, dim int64, index *Tensor, src *Tensor, reduce string, includeSelf bool, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + cincludeSelf := int32(0) + if includeSelf { cincludeSelf = int32(1) } + lib.Atg_ScatterReduceTwoOut(ptr, out.ctensor, ts.ctensor, dim, index.ctensor, src.ctensor, reduce, cincludeSelf) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ScatterReduceTwoOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ScatterReduceTwoOut") + + return retVal, err +} + // func.returns = `fixed 1`: // -------------------------- @@ -5503,11 +5717,13 @@ func _SparseCompressedTensorUnsafe(compressedIndices *Tensor, plainIndices *Tens // func.returns = `fixed 1`: // -------------------------- -func _SparseCooTensorUnsafe(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor, err error) { +func _SparseCooTensorUnsafe(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) sizeLen := len(size) - lib.Atg_SparseCooTensorUnsafe(ptr, indices.ctensor, values.ctensor, size, sizeLen, optionsKind.CInt(), optionsDevice.CInt()) +cisCoalesced := int32(0) + if isCoalesced { cisCoalesced = int32(1) } + lib.Atg_SparseCooTensorUnsafe(ptr, indices.ctensor, values.ctensor, size, sizeLen, optionsKind.CInt(), optionsDevice.CInt(), cisCoalesced) if err = TorchErr(); err != nil { err = fmt.Errorf("_SparseCooTensorUnsafe() failed: %w", err) return retVal, err @@ -5537,11 +5753,13 @@ func _SparseCooTensorWithDims(sparseDim int64, denseDim int64, size []int64, opt // func.returns = `fixed 1`: // -------------------------- -func _SparseCooTensorWithDimsAndTensors(sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor, err error) { +func _SparseCooTensorWithDimsAndTensors(sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) sizeLen := len(size) - lib.Atg_SparseCooTensorWithDimsAndTensors(ptr, sparseDim, denseDim, size, sizeLen, indices.ctensor, values.ctensor, optionsKind.CInt(), optionsDevice.CInt()) +cisCoalesced := int32(0) + if isCoalesced { cisCoalesced = int32(1) } + lib.Atg_SparseCooTensorWithDimsAndTensors(ptr, sparseDim, denseDim, size, sizeLen, indices.ctensor, values.ctensor, optionsKind.CInt(), optionsDevice.CInt(), cisCoalesced) if err = TorchErr(); err != nil { err = fmt.Errorf("_SparseCooTensorWithDimsAndTensors() failed: %w", err) return retVal, err @@ -5554,11 +5772,13 @@ func _SparseCooTensorWithDimsAndTensors(sparseDim int64, denseDim int64, size [] // func.returns = `fixed 1`: // -------------------------- -func _SparseCooTensorWithDimsAndTensorsOut(out *Tensor, sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor)(retVal *Tensor, err error) { +func _SparseCooTensorWithDimsAndTensorsOut(out *Tensor, sparseDim int64, denseDim int64, size []int64, indices *Tensor, values *Tensor, isCoalesced bool)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) sizeLen := len(size) - lib.Atg_SparseCooTensorWithDimsAndTensorsOut(ptr, out.ctensor, sparseDim, denseDim, size, sizeLen, indices.ctensor, values.ctensor) +cisCoalesced := int32(0) + if isCoalesced { cisCoalesced = int32(1) } + lib.Atg_SparseCooTensorWithDimsAndTensorsOut(ptr, out.ctensor, sparseDim, denseDim, size, sizeLen, indices.ctensor, values.ctensor, cisCoalesced) if err = TorchErr(); err != nil { err = fmt.Errorf("_SparseCooTensorWithDimsAndTensorsOut() failed: %w", err) return retVal, err @@ -5791,6 +6011,44 @@ func(ts *Tensor) _SparseLogSoftmaxOut(out *Tensor, dim int64, halfToFloat bool, // func.returns = `fixed 1`: // -------------------------- +func(ts *Tensor) _SparseMaskProjection(mask *Tensor, accumulateMatches bool, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + caccumulateMatches := int32(0) + if accumulateMatches { caccumulateMatches = int32(1) } + lib.Atg_SparseMaskProjection(ptr, ts.ctensor, mask.ctensor, caccumulateMatches) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_SparseMaskProjection() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_SparseMaskProjection") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _SparseMaskProjectionOut(out *Tensor, mask *Tensor, accumulateMatches bool, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + caccumulateMatches := int32(0) + if accumulateMatches { caccumulateMatches = int32(1) } + lib.Atg_SparseMaskProjectionOut(ptr, out.ctensor, ts.ctensor, mask.ctensor, caccumulateMatches) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_SparseMaskProjectionOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_SparseMaskProjectionOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func _SparseMm(sparse *Tensor, dense *Tensor)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -5841,6 +6099,22 @@ func(ts *Tensor) _SparseMmReduceImpl(other *Tensor, reduce string, del bool)(ret // func.returns = `fixed 1`: // -------------------------- +func _SparseSemiStructuredLinear(input *Tensor, weight *Tensor, meta *Tensor, bias *Tensor, activation string)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_SparseSemiStructuredLinear(ptr, input.ctensor, weight.ctensor, meta.ctensor, bias.ctensor, activation) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_SparseSemiStructuredLinear() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_SparseSemiStructuredLinear") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func(ts *Tensor) _SparseSoftmax(dim int64, halfToFloat bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -6379,6 +6653,40 @@ func(ts *Tensor) _TestCheckTensor(del bool)(retVal *Tensor, err error) { // func.returns = `fixed 1`: // -------------------------- +func(ts *Tensor) _TestFunctorchFallback(other *Tensor, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_TestFunctorchFallback(ptr, ts.ctensor, other.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_TestFunctorchFallback() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_TestFunctorchFallback") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _TestFunctorchFallbackOut(out *Tensor, other *Tensor, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_TestFunctorchFallbackOut(ptr, out.ctensor, ts.ctensor, other.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_TestFunctorchFallbackOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_TestFunctorchFallbackOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func _TestOptionalFilledIntlist(values *Tensor, addends []int64)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -6586,11 +6894,13 @@ func(ts *Tensor) _ToCopyOut(out *Tensor, nonBlocking bool, del bool)(retVal *Ten // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) _ToDense(dtype gotch.DType, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) _ToDense(dtype gotch.DType, maskedGrad bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - lib.Atg_ToDense(ptr, ts.ctensor, dtype.CInt()) + cmaskedGrad := int32(0) + if maskedGrad { cmaskedGrad = int32(1) } + lib.Atg_ToDense(ptr, ts.ctensor, dtype.CInt(), cmaskedGrad) if err = TorchErr(); err != nil { err = fmt.Errorf("_ToDense() failed: %w", err) return retVal, err @@ -6603,11 +6913,13 @@ func(ts *Tensor) _ToDense(dtype gotch.DType, del bool)(retVal *Tensor, err error // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) _ToDenseOut(out *Tensor, dtype gotch.DType, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) _ToDenseOut(out *Tensor, dtype gotch.DType, maskedGrad bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - lib.Atg_ToDenseOut(ptr, out.ctensor, ts.ctensor, dtype.CInt()) + cmaskedGrad := int32(0) + if maskedGrad { cmaskedGrad = int32(1) } + lib.Atg_ToDenseOut(ptr, out.ctensor, ts.ctensor, dtype.CInt(), cmaskedGrad) if err = TorchErr(); err != nil { err = fmt.Errorf("_ToDenseOut() failed: %w", err) return retVal, err @@ -6617,6 +6929,293 @@ func(ts *Tensor) _ToDenseOut(out *Tensor, dtype gotch.DType, del bool)(retVal *T return retVal, err } +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparse(layout Layout, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + blocksizeLen := len(blocksize) +var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparse(ptr, ts.ctensor, int8(layout), blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparse() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparse") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseBsc(blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + blocksizeLen := len(blocksize) +var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseBsc(ptr, ts.ctensor, blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseBsc() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseBsc") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseBscOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + blocksizeLen := len(blocksize) +var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseBscOut(ptr, out.ctensor, ts.ctensor, blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseBscOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseBscOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseBsr(blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + blocksizeLen := len(blocksize) +var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseBsr(ptr, ts.ctensor, blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseBsr() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseBsr") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseBsrOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + blocksizeLen := len(blocksize) +var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseBsrOut(ptr, out.ctensor, ts.ctensor, blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseBsrOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseBsrOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseCsc(denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseCsc(ptr, ts.ctensor, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseCsc() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseCsc") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseCscOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseCscOut(ptr, out.ctensor, ts.ctensor, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseCscOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseCscOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseCsr(denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseCsr(ptr, ts.ctensor, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseCsr() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseCsr") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseCsrOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseCsrOut(ptr, out.ctensor, ts.ctensor, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseCsrOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseCsrOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseOut(out *Tensor, layout Layout, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + blocksizeLen := len(blocksize) +var cdenseDimVal int64 = 0 + var cdenseDimNull int = 1 + if len(denseDim) > 0 { + cdenseDimVal = denseDim[0] + cdenseDimNull = 0 + } + lib.Atg_ToSparseOut(ptr, out.ctensor, ts.ctensor, int8(layout), blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseOut") + + return retVal, err +} + +// func.returns = `fixed ntensors`: +// --------------------------------- +func _ToSparseSemiStructured(dense *Tensor)(retVal0 *Tensor, retVal1 *Tensor, err error) { + ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) + + lib.Atg_ToSparseSemiStructured(ctensorPtr0, dense.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseSemiStructured() failed: %w", err) + return retVal0, retVal1, err + } + retVal0 = newTensor(*ctensorPtr0, "_ToSparseSemiStructured_0") + retVal1 = newTensor(*ctensorPtr1, "_ToSparseSemiStructured_1") + + return retVal0, retVal1, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseSparseDim(sparseDim int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_ToSparseSparseDim(ptr, ts.ctensor, sparseDim) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseSparseDim() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseSparseDim") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _ToSparseSparseDimOut(out *Tensor, sparseDim int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.Atg_ToSparseSparseDimOut(ptr, out.ctensor, ts.ctensor, sparseDim) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_ToSparseSparseDimOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_ToSparseSparseDimOut") + + return retVal, err +} + // func.returns = `fixed ntensors`: // --------------------------------- func _TransformBiasRescaleQkv(qkv *Tensor, qkvBias *Tensor, numHeads int64)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { @@ -6655,52 +7254,6 @@ func _TransformBiasRescaleQkvOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, qkv * return retVal0, retVal1, retVal2, err } -// func.returns = `fixed ntensors`: -// --------------------------------- -func _TransformerDecoderOnlyLayerFwd(src *Tensor, embedDim int64, numHeads int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, useGelu bool, normFirst bool, eps float64, normWeight1 *Tensor, normBias1 *Tensor, normWeight2 *Tensor, normBias2 *Tensor, ffnWeight1 *Tensor, ffnBias1 *Tensor, ffnWeight2 *Tensor, ffnBias2 *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { - ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) - ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) - - cuseGelu := int32(0) - if useGelu { cuseGelu = int32(1) } -cnormFirst := int32(0) - if normFirst { cnormFirst = int32(1) } - lib.Atg_TransformerDecoderOnlyLayerFwd(ctensorPtr0, src.ctensor, embedDim, numHeads, qkvWeight.ctensor, qkvBias.ctensor, projWeight.ctensor, projBias.ctensor, cuseGelu, cnormFirst, eps, normWeight1.ctensor, normBias1.ctensor, normWeight2.ctensor, normBias2.ctensor, ffnWeight1.ctensor, ffnBias1.ctensor, ffnWeight2.ctensor, ffnBias2.ctensor, mask.ctensor, incrKey.ctensor, incrValue.ctensor) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_TransformerDecoderOnlyLayerFwd() failed: %w", err) - return retVal0, retVal1, retVal2, err - } - retVal0 = newTensor(*ctensorPtr0, "_TransformerDecoderOnlyLayerFwd_0") - retVal1 = newTensor(*ctensorPtr1, "_TransformerDecoderOnlyLayerFwd_1") - retVal2 = newTensor(*ctensorPtr2, "_TransformerDecoderOnlyLayerFwd_2") - - return retVal0, retVal1, retVal2, err -} - -// func.returns = `fixed ntensors`: -// --------------------------------- -func _TransformerDecoderOnlyLayerFwdOut(out0 *Tensor, out1 *Tensor, out2 *Tensor, src *Tensor, embedDim int64, numHeads int64, qkvWeight *Tensor, qkvBias *Tensor, projWeight *Tensor, projBias *Tensor, useGelu bool, normFirst bool, eps float64, normWeight1 *Tensor, normBias1 *Tensor, normWeight2 *Tensor, normBias2 *Tensor, ffnWeight1 *Tensor, ffnBias1 *Tensor, ffnWeight2 *Tensor, ffnBias2 *Tensor, mask *Tensor, incrKey *Tensor, incrValue *Tensor)(retVal0 *Tensor, retVal1 *Tensor, retVal2 *Tensor, err error) { - ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) - ctensorPtr2 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr1)) + unsafe.Sizeof(ctensorPtr0))) - - cuseGelu := int32(0) - if useGelu { cuseGelu = int32(1) } -cnormFirst := int32(0) - if normFirst { cnormFirst = int32(1) } - lib.Atg_TransformerDecoderOnlyLayerFwdOut(ctensorPtr0, out0.ctensor, out1.ctensor, out2.ctensor, src.ctensor, embedDim, numHeads, qkvWeight.ctensor, qkvBias.ctensor, projWeight.ctensor, projBias.ctensor, cuseGelu, cnormFirst, eps, normWeight1.ctensor, normBias1.ctensor, normWeight2.ctensor, normBias2.ctensor, ffnWeight1.ctensor, ffnBias1.ctensor, ffnWeight2.ctensor, ffnBias2.ctensor, mask.ctensor, incrKey.ctensor, incrValue.ctensor) - if err = TorchErr(); err != nil { - err = fmt.Errorf("_TransformerDecoderOnlyLayerFwdOut() failed: %w", err) - return retVal0, retVal1, retVal2, err - } - retVal0 = newTensor(*ctensorPtr0, "_TransformerDecoderOnlyLayerFwdOut_0") - retVal1 = newTensor(*ctensorPtr1, "_TransformerDecoderOnlyLayerFwdOut_1") - retVal2 = newTensor(*ctensorPtr2, "_TransformerDecoderOnlyLayerFwdOut_2") - - return retVal0, retVal1, retVal2, err -} - // func.returns = `fixed 1`: // -------------------------- @@ -6973,6 +7526,46 @@ func _UnpackDual(dual *Tensor, level int64)(retVal0 *Tensor, retVal1 *Tensor, er // func.returns = `fixed 1`: // -------------------------- +func(ts *Tensor) _UnsafeIndex(indices []*Tensor, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cindices []lib.Ctensor + for _, t := range indices {cindices = append(cindices, t.ctensor)} + lib.Atg_UnsafeIndex(ptr, ts.ctensor, cindices, len(cindices)) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_UnsafeIndex() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_UnsafeIndex") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) _UnsafeIndexPut(indices []*Tensor, values *Tensor, accumulate bool, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + var cindices []lib.Ctensor + for _, t := range indices {cindices = append(cindices, t.ctensor)} +caccumulate := int32(0) + if accumulate { caccumulate = int32(1) } + lib.Atg_UnsafeIndexPut(ptr, ts.ctensor, cindices, len(cindices), values.ctensor, caccumulate) + if err = TorchErr(); err != nil { + err = fmt.Errorf("_UnsafeIndexPut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "_UnsafeIndexPut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func(ts *Tensor) _UnsafeView(size []int64, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -10723,10 +11316,10 @@ ccudnnEnabled := int32(0) // func.returns = `fixed 1`: // -------------------------- -func BatchNormBackwardElemt(gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, meanDy *Tensor, meanDyXmu *Tensor, count *Tensor)(retVal *Tensor, err error) { +func BatchNormBackwardElemt(gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, sumDy *Tensor, sumDyXmu *Tensor, count *Tensor)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - lib.AtgBatchNormBackwardElemt(ptr, gradOut.ctensor, input.ctensor, mean.ctensor, invstd.ctensor, weight.ctensor, meanDy.ctensor, meanDyXmu.ctensor, count.ctensor) + lib.AtgBatchNormBackwardElemt(ptr, gradOut.ctensor, input.ctensor, mean.ctensor, invstd.ctensor, weight.ctensor, sumDy.ctensor, sumDyXmu.ctensor, count.ctensor) if err = TorchErr(); err != nil { err = fmt.Errorf("BatchNormBackwardElemt() failed: %w", err) return retVal, err @@ -10739,10 +11332,10 @@ func BatchNormBackwardElemt(gradOut *Tensor, input *Tensor, mean *Tensor, invstd // func.returns = `fixed 1`: // -------------------------- -func BatchNormBackwardElemtOut(out *Tensor, gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, meanDy *Tensor, meanDyXmu *Tensor, count *Tensor)(retVal *Tensor, err error) { +func BatchNormBackwardElemtOut(out *Tensor, gradOut *Tensor, input *Tensor, mean *Tensor, invstd *Tensor, weight *Tensor, sumDy *Tensor, sumDyXmu *Tensor, count *Tensor)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - lib.AtgBatchNormBackwardElemtOut(ptr, out.ctensor, gradOut.ctensor, input.ctensor, mean.ctensor, invstd.ctensor, weight.ctensor, meanDy.ctensor, meanDyXmu.ctensor, count.ctensor) + lib.AtgBatchNormBackwardElemtOut(ptr, out.ctensor, gradOut.ctensor, input.ctensor, mean.ctensor, invstd.ctensor, weight.ctensor, sumDy.ctensor, sumDyXmu.ctensor, count.ctensor) if err = TorchErr(); err != nil { err = fmt.Errorf("BatchNormBackwardElemtOut() failed: %w", err) return retVal, err @@ -16481,6 +17074,42 @@ func EmptyOut(out *Tensor, size []int64)(retVal *Tensor, err error) { // func.returns = `fixed 1`: // -------------------------- +func EmptyPermuted(size []int64, physicalLayout []int64, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + sizeLen := len(size) +physicalLayoutLen := len(physicalLayout) + lib.AtgEmptyPermuted(ptr, size, sizeLen, physicalLayout, physicalLayoutLen, optionsKind.CInt(), optionsDevice.CInt()) + if err = TorchErr(); err != nil { + err = fmt.Errorf("EmptyPermuted() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "EmptyPermuted") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func EmptyPermutedOut(out *Tensor, size []int64, physicalLayout []int64)(retVal *Tensor, err error) { + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + sizeLen := len(size) +physicalLayoutLen := len(physicalLayout) + lib.AtgEmptyPermutedOut(ptr, out.ctensor, size, sizeLen, physicalLayout, physicalLayoutLen) + if err = TorchErr(); err != nil { + err = fmt.Errorf("EmptyPermutedOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "EmptyPermutedOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func EmptyQuantized(size []int64, qtensor *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -27612,6 +28241,23 @@ func(ts *Tensor) MinOut(out *Tensor, other *Tensor, del bool)(retVal *Tensor, er // func.returns = `fixed 1`: // -------------------------- +func(ts *Tensor) MinUnaryOut(out *Tensor, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.AtgMinUnaryOut(ptr, out.ctensor, ts.ctensor) + if err = TorchErr(); err != nil { + err = fmt.Errorf("MinUnaryOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "MinUnaryOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func(ts *Tensor) Minimum(other *Tensor, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -30677,6 +31323,40 @@ func(ts *Tensor) NonzeroOut(out *Tensor, del bool)(retVal *Tensor, err error) { // func.returns = `fixed 1`: // -------------------------- +func(ts *Tensor) NonzeroStatic(size int64, fillValue int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.AtgNonzeroStatic(ptr, ts.ctensor, size, fillValue) + if err = TorchErr(); err != nil { + err = fmt.Errorf("NonzeroStatic() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "NonzeroStatic") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) NonzeroStaticOut(out *Tensor, size int64, fillValue int64, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + lib.AtgNonzeroStaticOut(ptr, out.ctensor, ts.ctensor, size, fillValue) + if err = TorchErr(); err != nil { + err = fmt.Errorf("NonzeroStaticOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "NonzeroStaticOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func(ts *Tensor) Norm(del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -32454,6 +33134,52 @@ cceilMode := int32(0) // func.returns = `fixed 1`: // -------------------------- +func(ts *Tensor) QuantizedMaxPool3d(kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + kernelSizeLen := len(kernelSize) +strideLen := len(stride) +paddingLen := len(padding) +dilationLen := len(dilation) +cceilMode := int32(0) + if ceilMode { cceilMode = int32(1) } + lib.AtgQuantizedMaxPool3d(ptr, ts.ctensor, kernelSize, kernelSizeLen, stride, strideLen, padding, paddingLen, dilation, dilationLen, cceilMode) + if err = TorchErr(); err != nil { + err = fmt.Errorf("QuantizedMaxPool3d() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "QuantizedMaxPool3d") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + +func(ts *Tensor) QuantizedMaxPool3dOut(out *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool, del bool)(retVal *Tensor, err error) { + if del { defer ts.MustDrop() } + ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) + + kernelSizeLen := len(kernelSize) +strideLen := len(stride) +paddingLen := len(padding) +dilationLen := len(dilation) +cceilMode := int32(0) + if ceilMode { cceilMode = int32(1) } + lib.AtgQuantizedMaxPool3dOut(ptr, out.ctensor, ts.ctensor, kernelSize, kernelSizeLen, stride, strideLen, padding, paddingLen, dilation, dilationLen, cceilMode) + if err = TorchErr(); err != nil { + err = fmt.Errorf("QuantizedMaxPool3dOut() failed: %w", err) + return retVal, err + } + retVal = newTensor(*ptr, "QuantizedMaxPool3dOut") + + return retVal, err +} + +// func.returns = `fixed 1`: +// -------------------------- + func QuantizedRnnReluCell(input *Tensor, hx *Tensor, wIh *Tensor, wHh *Tensor, bIh *Tensor, bHh *Tensor, packedIh *Tensor, packedHh *Tensor, colOffsetsIh *Tensor, colOffsetsHh *Tensor, scaleIh *Scalar, scaleHh *Scalar, zeroPointIh *Scalar, zeroPointHh *Scalar)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -34926,12 +35652,18 @@ func ScalarTensorOut(out *Tensor, s *Scalar)(retVal *Tensor, err error) { // func.returns = `fixed 1`: // -------------------------- -func ScaledDotProductAttention(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool)(retVal *Tensor, err error) { +func ScaledDotProductAttention(query *Tensor, key *Tensor, value *Tensor, attnMask *Tensor, dropoutP float64, isCausal bool, scale []float64)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) cisCausal := int32(0) if isCausal { cisCausal = int32(1) } - lib.AtgScaledDotProductAttention(ptr, query.ctensor, key.ctensor, value.ctensor, attnMask.ctensor, dropoutP, cisCausal) +var cscaleVal float64 = 0.0 + var cscaleNull int = 1 + if len(scale) > 0 { + cscaleVal = scale[0] + cscaleNull = 0 + } + lib.AtgScaledDotProductAttention(ptr, query.ctensor, key.ctensor, value.ctensor, attnMask.ctensor, dropoutP, cisCausal, cscaleVal, cscaleNull) if err = TorchErr(); err != nil { err = fmt.Errorf("ScaledDotProductAttention() failed: %w", err) return retVal, err @@ -37001,10 +37733,12 @@ func SparseCooTensor(size []int64, optionsKind gotch.DType, optionsDevice gotch. // func.returns = `fixed 1`: // -------------------------- -func SparseCooTensorIndices(indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor, err error) { +func SparseCooTensorIndices(indices *Tensor, values *Tensor, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - lib.AtgSparseCooTensorIndices(ptr, indices.ctensor, values.ctensor, optionsKind.CInt(), optionsDevice.CInt()) + cisCoalesced := int32(0) + if isCoalesced { cisCoalesced = int32(1) } + lib.AtgSparseCooTensorIndices(ptr, indices.ctensor, values.ctensor, optionsKind.CInt(), optionsDevice.CInt(), cisCoalesced) if err = TorchErr(); err != nil { err = fmt.Errorf("SparseCooTensorIndices() failed: %w", err) return retVal, err @@ -37017,11 +37751,13 @@ func SparseCooTensorIndices(indices *Tensor, values *Tensor, optionsKind gotch.D // func.returns = `fixed 1`: // -------------------------- -func SparseCooTensorIndicesSize(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device)(retVal *Tensor, err error) { +func SparseCooTensorIndicesSize(indices *Tensor, values *Tensor, size []int64, optionsKind gotch.DType, optionsDevice gotch.Device, isCoalesced bool)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) sizeLen := len(size) - lib.AtgSparseCooTensorIndicesSize(ptr, indices.ctensor, values.ctensor, size, sizeLen, optionsKind.CInt(), optionsDevice.CInt()) +cisCoalesced := int32(0) + if isCoalesced { cisCoalesced = int32(1) } + lib.AtgSparseCooTensorIndicesSize(ptr, indices.ctensor, values.ctensor, size, sizeLen, optionsKind.CInt(), optionsDevice.CInt(), cisCoalesced) if err = TorchErr(); err != nil { err = fmt.Errorf("SparseCooTensorIndicesSize() failed: %w", err) return retVal, err @@ -40520,20 +41256,14 @@ func(ts *Tensor) Std(unbiased bool, del bool)(retVal *Tensor, err error) { // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) StdCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) StdCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgStdCorrection(ptr, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgStdCorrection(ptr, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("StdCorrection() failed: %w", err) return retVal, err @@ -40546,20 +41276,14 @@ ckeepdim := int32(0) // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) StdCorrectionOut(out *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) StdCorrectionOut(out *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgStdCorrectionOut(ptr, out.ctensor, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgStdCorrectionOut(ptr, out.ctensor, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("StdCorrectionOut() failed: %w", err) return retVal, err @@ -40613,21 +41337,15 @@ func(ts *Tensor) StdMean(unbiased bool, del bool)(retVal0 *Tensor, retVal1 *Tens // func.returns = `fixed ntensors`: // --------------------------------- -func(ts *Tensor) StdMeanCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { +func(ts *Tensor) StdMeanCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { if del { defer ts.MustDrop() } ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgStdMeanCorrection(ctensorPtr0, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgStdMeanCorrection(ctensorPtr0, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("StdMeanCorrection() failed: %w", err) return retVal0, retVal1, err @@ -40640,21 +41358,15 @@ ckeepdim := int32(0) // func.returns = `fixed ntensors`: // --------------------------------- -func(ts *Tensor) StdMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { +func(ts *Tensor) StdMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { if del { defer ts.MustDrop() } ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgStdMeanCorrectionOut(ctensorPtr0, out0.ctensor, out1.ctensor, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgStdMeanCorrectionOut(ctensorPtr0, out0.ctensor, out1.ctensor, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("StdMeanCorrectionOut() failed: %w", err) return retVal0, retVal1, err @@ -41610,11 +42322,13 @@ func(ts *Tensor) To(device gotch.Device, del bool)(retVal *Tensor, err error) { // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) ToDense(dtype gotch.DType, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) ToDense(dtype gotch.DType, maskedGrad bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - lib.AtgToDense(ptr, ts.ctensor, dtype.CInt()) + cmaskedGrad := int32(0) + if maskedGrad { cmaskedGrad = int32(1) } + lib.AtgToDense(ptr, ts.ctensor, dtype.CInt(), cmaskedGrad) if err = TorchErr(); err != nil { err = fmt.Errorf("ToDense() failed: %w", err) return retVal, err @@ -41627,10 +42341,12 @@ func(ts *Tensor) ToDense(dtype gotch.DType, del bool)(retVal *Tensor, err error) // func.returns = `fixed 1`: // -------------------------- -func ToDenseBackward(grad *Tensor, input *Tensor)(retVal *Tensor, err error) { +func ToDenseBackward(grad *Tensor, input *Tensor, maskedGrad bool)(retVal *Tensor, err error) { ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - lib.AtgToDenseBackward(ptr, grad.ctensor, input.ctensor) + cmaskedGrad := int32(0) + if maskedGrad { cmaskedGrad = int32(1) } + lib.AtgToDenseBackward(ptr, grad.ctensor, input.ctensor, cmaskedGrad) if err = TorchErr(); err != nil { err = fmt.Errorf("ToDenseBackward() failed: %w", err) return retVal, err @@ -41861,30 +42577,6 @@ var cdenseDimVal int64 = 0 // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) ToSparseBscOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { - if del { defer ts.MustDrop() } - ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - - blocksizeLen := len(blocksize) -var cdenseDimVal int64 = 0 - var cdenseDimNull int = 1 - if len(denseDim) > 0 { - cdenseDimVal = denseDim[0] - cdenseDimNull = 0 - } - lib.AtgToSparseBscOut(ptr, out.ctensor, ts.ctensor, blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) - if err = TorchErr(); err != nil { - err = fmt.Errorf("ToSparseBscOut() failed: %w", err) - return retVal, err - } - retVal = newTensor(*ptr, "ToSparseBscOut") - - return retVal, err -} - -// func.returns = `fixed 1`: -// -------------------------- - func(ts *Tensor) ToSparseBsr(blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -41909,30 +42601,6 @@ var cdenseDimVal int64 = 0 // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) ToSparseBsrOut(out *Tensor, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { - if del { defer ts.MustDrop() } - ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - - blocksizeLen := len(blocksize) -var cdenseDimVal int64 = 0 - var cdenseDimNull int = 1 - if len(denseDim) > 0 { - cdenseDimVal = denseDim[0] - cdenseDimNull = 0 - } - lib.AtgToSparseBsrOut(ptr, out.ctensor, ts.ctensor, blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) - if err = TorchErr(); err != nil { - err = fmt.Errorf("ToSparseBsrOut() failed: %w", err) - return retVal, err - } - retVal = newTensor(*ptr, "ToSparseBsrOut") - - return retVal, err -} - -// func.returns = `fixed 1`: -// -------------------------- - func(ts *Tensor) ToSparseCsc(denseDim []int64, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -41956,29 +42624,6 @@ func(ts *Tensor) ToSparseCsc(denseDim []int64, del bool)(retVal *Tensor, err err // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) ToSparseCscOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor, err error) { - if del { defer ts.MustDrop() } - ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - - var cdenseDimVal int64 = 0 - var cdenseDimNull int = 1 - if len(denseDim) > 0 { - cdenseDimVal = denseDim[0] - cdenseDimNull = 0 - } - lib.AtgToSparseCscOut(ptr, out.ctensor, ts.ctensor, cdenseDimVal, cdenseDimNull) - if err = TorchErr(); err != nil { - err = fmt.Errorf("ToSparseCscOut() failed: %w", err) - return retVal, err - } - retVal = newTensor(*ptr, "ToSparseCscOut") - - return retVal, err -} - -// func.returns = `fixed 1`: -// -------------------------- - func(ts *Tensor) ToSparseCsr(denseDim []int64, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -42002,53 +42647,6 @@ func(ts *Tensor) ToSparseCsr(denseDim []int64, del bool)(retVal *Tensor, err err // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) ToSparseCsrOut(out *Tensor, denseDim []int64, del bool)(retVal *Tensor, err error) { - if del { defer ts.MustDrop() } - ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - - var cdenseDimVal int64 = 0 - var cdenseDimNull int = 1 - if len(denseDim) > 0 { - cdenseDimVal = denseDim[0] - cdenseDimNull = 0 - } - lib.AtgToSparseCsrOut(ptr, out.ctensor, ts.ctensor, cdenseDimVal, cdenseDimNull) - if err = TorchErr(); err != nil { - err = fmt.Errorf("ToSparseCsrOut() failed: %w", err) - return retVal, err - } - retVal = newTensor(*ptr, "ToSparseCsrOut") - - return retVal, err -} - -// func.returns = `fixed 1`: -// -------------------------- - -func(ts *Tensor) ToSparseOut(out *Tensor, layout Layout, blocksize []int64, denseDim []int64, del bool)(retVal *Tensor, err error) { - if del { defer ts.MustDrop() } - ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - - blocksizeLen := len(blocksize) -var cdenseDimVal int64 = 0 - var cdenseDimNull int = 1 - if len(denseDim) > 0 { - cdenseDimVal = denseDim[0] - cdenseDimNull = 0 - } - lib.AtgToSparseOut(ptr, out.ctensor, ts.ctensor, int8(layout), blocksize, blocksizeLen, cdenseDimVal, cdenseDimNull) - if err = TorchErr(); err != nil { - err = fmt.Errorf("ToSparseOut() failed: %w", err) - return retVal, err - } - retVal = newTensor(*ptr, "ToSparseOut") - - return retVal, err -} - -// func.returns = `fixed 1`: -// -------------------------- - func(ts *Tensor) ToSparseSparseDim(sparseDim int64, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) @@ -42063,23 +42661,6 @@ func(ts *Tensor) ToSparseSparseDim(sparseDim int64, del bool)(retVal *Tensor, er return retVal, err } -// func.returns = `fixed 1`: -// -------------------------- - -func(ts *Tensor) ToSparseSparseDimOut(out *Tensor, sparseDim int64, del bool)(retVal *Tensor, err error) { - if del { defer ts.MustDrop() } - ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) - - lib.AtgToSparseSparseDimOut(ptr, out.ctensor, ts.ctensor, sparseDim) - if err = TorchErr(); err != nil { - err = fmt.Errorf("ToSparseSparseDimOut() failed: %w", err) - return retVal, err - } - retVal = newTensor(*ptr, "ToSparseSparseDimOut") - - return retVal, err -} - // func.returns = `fixed ntensors`: // --------------------------------- func(ts *Tensor) Topk(k int64, dim int64, largest bool, sorted bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { @@ -44205,20 +44786,14 @@ func(ts *Tensor) Var(unbiased bool, del bool)(retVal *Tensor, err error) { // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) VarCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) VarCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgVarCorrection(ptr, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgVarCorrection(ptr, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("VarCorrection() failed: %w", err) return retVal, err @@ -44231,20 +44806,14 @@ ckeepdim := int32(0) // func.returns = `fixed 1`: // -------------------------- -func(ts *Tensor) VarCorrectionOut(out *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal *Tensor, err error) { +func(ts *Tensor) VarCorrectionOut(out *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal *Tensor, err error) { if del { defer ts.MustDrop() } ptr := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgVarCorrectionOut(ptr, out.ctensor, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgVarCorrectionOut(ptr, out.ctensor, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("VarCorrectionOut() failed: %w", err) return retVal, err @@ -44298,21 +44867,15 @@ func(ts *Tensor) VarMean(unbiased bool, del bool)(retVal0 *Tensor, retVal1 *Tens // func.returns = `fixed ntensors`: // --------------------------------- -func(ts *Tensor) VarMeanCorrection(dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { +func(ts *Tensor) VarMeanCorrection(dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { if del { defer ts.MustDrop() } ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgVarMeanCorrection(ctensorPtr0, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgVarMeanCorrection(ctensorPtr0, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("VarMeanCorrection() failed: %w", err) return retVal0, retVal1, err @@ -44325,21 +44888,15 @@ ckeepdim := int32(0) // func.returns = `fixed ntensors`: // --------------------------------- -func(ts *Tensor) VarMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction []int64, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { +func(ts *Tensor) VarMeanCorrectionOut(out0 *Tensor, out1 *Tensor, dim []int64, correction *Scalar, keepdim bool, del bool)(retVal0 *Tensor, retVal1 *Tensor, err error) { if del { defer ts.MustDrop() } ctensorPtr0 := (*lib.Ctensor)(unsafe.Pointer(C.malloc(0))) ctensorPtr1 := (*lib.Ctensor)(unsafe.Pointer(uintptr(unsafe.Pointer(ctensorPtr0)) + unsafe.Sizeof(ctensorPtr0))) dimLen := len(dim) -var ccorrectionVal int64 = 0 - var ccorrectionNull int = 1 - if len(correction) > 0 { - ccorrectionVal = correction[0] - ccorrectionNull = 0 - } ckeepdim := int32(0) if keepdim { ckeepdim = int32(1) } - lib.AtgVarMeanCorrectionOut(ctensorPtr0, out0.ctensor, out1.ctensor, ts.ctensor, dim, dimLen, ccorrectionVal, ccorrectionNull, ckeepdim) + lib.AtgVarMeanCorrectionOut(ctensorPtr0, out0.ctensor, out1.ctensor, ts.ctensor, dim, dimLen, correction.cscalar, ckeepdim) if err = TorchErr(); err != nil { err = fmt.Errorf("VarMeanCorrectionOut() failed: %w", err) return retVal0, retVal1, err