diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_add_relu_cpu_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_add_relu_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..589725f0c02111130b5ebd55d7827cbe06a84df8 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_add_relu_cpu_dispatch.h @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor _add_relu(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1); +TORCH_API at::Tensor & _add_relu_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1); +TORCH_API at::Tensor & _add_relu_outf(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out); +TORCH_API at::Tensor & _add_relu_(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha=1); +TORCH_API at::Tensor _add_relu(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha=1); +TORCH_API at::Tensor & _add_relu_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha=1); + +} // namespace cpu +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_forward.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_forward.h new file mode 100644 index 0000000000000000000000000000000000000000..7ac3b1dc4f199095ee91985301209d121b3194e3 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_forward.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_cdist_forward(Tensor x1, Tensor x2, float p, int? compute_mode) -> Tensor +inline at::Tensor _cdist_forward(const at::Tensor & x1, const at::Tensor & x2, double p, c10::optional compute_mode) { + return at::_ops::_cdist_forward::call(x1, x2, p, compute_mode); +} + +// aten::_cdist_forward.out(Tensor x1, Tensor x2, float p, int? compute_mode, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _cdist_forward_out(at::Tensor & out, const at::Tensor & x1, const at::Tensor & x2, double p, c10::optional compute_mode) { + return at::_ops::_cdist_forward_out::call(x1, x2, p, compute_mode, out); +} +// aten::_cdist_forward.out(Tensor x1, Tensor x2, float p, int? compute_mode, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _cdist_forward_outf(const at::Tensor & x1, const at::Tensor & x2, double p, c10::optional compute_mode, at::Tensor & out) { + return at::_ops::_cdist_forward_out::call(x1, x2, p, compute_mode, out); +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward.h new file mode 100644 index 0000000000000000000000000000000000000000..b32eab27099384f71e82ff36dc2b833bcdcd1616 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_backward.h @@ -0,0 +1,30 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// 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) +inline ::std::tuple _fake_quantize_learnable_per_channel_affine_backward(const at::Tensor & grad, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max, double grad_factor=1.0) { + return at::_ops::_fake_quantize_learnable_per_channel_affine_backward::call(grad, self, scale, zero_point, axis, quant_min, quant_max, grad_factor); +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foobar_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foobar_native.h new file mode 100644 index 0000000000000000000000000000000000000000..70dd73faee8bd76517c28122eb41607c57b00b52 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foobar_native.h @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & _foobar_out(const at::Tensor & self, bool arg1, bool arg2, bool arg3, at::Tensor & out); +TORCH_API at::Tensor foobar(const at::Tensor & self, bool arg1=true, bool arg2=true, bool arg3=true); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_lgamma_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_lgamma_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..a511e8ab6cc7f19c1a148e5ee72b6c38e0ea9d1d --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_lgamma_ops.h @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _foreach_lgamma { + using schema = ::std::vector (at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_lgamma") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_lgamma(Tensor[] self) -> Tensor[]") + static ::std::vector call(at::TensorList self); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self); +}; + +struct TORCH_API _foreach_lgamma_ { + using schema = void (at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_lgamma_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_lgamma_(Tensor(a!)[] self) -> ()") + static void call(at::TensorList self); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self); +}; + +struct TORCH_API _foreach_lgamma_out { + using schema = void (at::TensorList, at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_lgamma") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_lgamma.out(Tensor[] self, *, Tensor(a!)[] out) -> ()") + static void call(at::TensorList self, at::TensorList out); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::TensorList out); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_log2_compositeexplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_log2_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..ea6cd9a690771fbf690e9e97cf28af4d2b296d61 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_log2_compositeexplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API void _foreach_log2_out(at::TensorList out, at::TensorList self); +TORCH_API void _foreach_log2_outf(at::TensorList self, at::TensorList out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_index_put_impl_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_index_put_impl_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9b85a16eb42b94b22f3e37bcf95dc62317b676a4 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_index_put_impl_cuda_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor & _index_put_impl_(at::Tensor & self, const c10::List> & indices, const at::Tensor & values, bool accumulate=false, bool unsafe=false); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_lu_with_info_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_lu_with_info_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..063523ec568a15d18933b128e72fb469555ce8d2 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_lu_with_info_compositeimplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API ::std::tuple _lu_with_info(const at::Tensor & self, bool pivot=true, bool check_errors=true); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_softmax_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_softmax_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..e125441d32ff5a72d7f5d03b52587c050520dd41 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_masked_softmax_cuda_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor _masked_softmax(const at::Tensor & self, const at::Tensor & mask, c10::optional dim=c10::nullopt, c10::optional mask_type=c10::nullopt); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_mps_convolution_transpose_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_mps_convolution_transpose_native.h new file mode 100644 index 0000000000000000000000000000000000000000..3b1a6982778b33660c59fc4e8a64b22c3c758e12 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_mps_convolution_transpose_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & _mps_convolution_transpose_out(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_tensor_size_compositeexplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_tensor_size_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..f2a02ec4c81260ef7afa307797315c883d6ea9f8 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_nested_tensor_size_compositeexplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & _nested_tensor_size_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & _nested_tensor_size_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_reshape_alias_copy_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_reshape_alias_copy_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..67c888f4b27eaa752017235cbca44c44b9ac9ea1 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_reshape_alias_copy_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _reshape_alias_copy { + using schema = at::Tensor (const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_reshape_alias_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_reshape_alias_copy(Tensor self, SymInt[] size, SymInt[] stride) -> Tensor") + static at::Tensor call(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride); +}; + +struct TORCH_API _reshape_alias_copy_out { + using schema = at::Tensor & (const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_reshape_alias_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_reshape_alias_copy.out(Tensor self, SymInt[] size, SymInt[] stride, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_dot_product_attention_math.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_dot_product_attention_math.h new file mode 100644 index 0000000000000000000000000000000000000000..42b556da84536bcdfd0e047a98c472c075234846 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_dot_product_attention_math.h @@ -0,0 +1,30 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// 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) -> (Tensor, Tensor) +inline ::std::tuple _scaled_dot_product_attention_math(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const c10::optional & attn_mask={}, double dropout_p=0.0, bool is_causal=false, const c10::optional & dropout_mask={}) { + return at::_ops::_scaled_dot_product_attention_math::call(query, key, value, attn_mask, dropout_p, is_causal, dropout_mask); +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_csr_prod_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_csr_prod_native.h new file mode 100644 index 0000000000000000000000000000000000000000..5fe3f7801bd2b20422e8c4546bf6e7547ff98535 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_csr_prod_native.h @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & _sparse_csr_prod_dim_dtype_out(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, c10::optional dtype, at::Tensor & out); +TORCH_API at::Tensor _sparse_csr_prod_cpu(const at::Tensor & self, at::IntArrayRef dim, bool keepdim=false, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor _sparse_csr_prod_cuda(const at::Tensor & self, at::IntArrayRef dim, bool keepdim=false, c10::optional dtype=c10::nullopt); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_unsafe_view_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_unsafe_view_native.h new file mode 100644 index 0000000000000000000000000000000000000000..cf6c3dc26b4f3ce9366e1c3b5fc4dd4f8c34a945 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_unsafe_view_native.h @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor _unsafe_view(const at::Tensor & self, at::IntArrayRef size); +TORCH_API at::Tensor & _unsafe_view_out_symint(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact3d_backward_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact3d_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..38aebe74da39c71450e2d32e09d97fd2849d35db --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_upsample_nearest_exact3d_backward_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _upsample_nearest_exact3d_backward_grad_input { + using schema = at::Tensor & (const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::optional, c10::optional, c10::optional, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_upsample_nearest_exact3d_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "grad_input") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_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!)") + static at::Tensor & call(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & grad_input); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & grad_input); +}; + +struct TORCH_API _upsample_nearest_exact3d_backward { + using schema = at::Tensor (const at::Tensor &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::optional, c10::optional, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_upsample_nearest_exact3d_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_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") + static at::Tensor call(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/abs_compositeexplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/abs_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..525396d407c731a5137f91f307b58e6d620e097f --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/abs_compositeexplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor abs(const at::Tensor & self); +TORCH_API at::Tensor & abs_(at::Tensor & self); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_avg_pool3d_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_avg_pool3d_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9eefa559e3eadca55dad3f974a90f2ee1ad4aba7 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/adaptive_avg_pool3d_compositeimplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor adaptive_avg_pool3d(const at::Tensor & self, at::IntArrayRef output_size); +TORCH_API at::Tensor adaptive_avg_pool3d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/addmm_meta_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/addmm_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..e945077c8928a64ce4bbfec00f4bdfff663dfe84 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/addmm_meta_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor addmm(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta=1, const at::Scalar & alpha=1); +TORCH_API at::Tensor & addmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta=1, const at::Scalar & alpha=1); +TORCH_API at::Tensor & addmm_outf(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out); +TORCH_API at::Tensor & addmm_(at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta=1, const at::Scalar & alpha=1); + +} // namespace meta +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/any_cpu_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/any_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9b1e529b510ef8c3076b6db3d892515baf4fb87b --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/any_cpu_dispatch.h @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor any(const at::Tensor & self, int64_t dim, bool keepdim=false); +TORCH_API at::Tensor & any_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool keepdim=false); +TORCH_API at::Tensor & any_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out); +TORCH_API at::Tensor any(const at::Tensor & self); +TORCH_API at::Tensor & any_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & any_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/asin_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/asin_native.h new file mode 100644 index 0000000000000000000000000000000000000000..7b7b86d25df7c65860375c9e3d062968d6d267e8 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/asin_native.h @@ -0,0 +1,29 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_asin_out : public at::meta::structured_asin { +void impl(const at::Tensor & self, const at::Tensor & out); +}; +TORCH_API at::Tensor asin_sparse(const at::Tensor & self); +TORCH_API at::Tensor & asin_sparse_out(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & asin_sparse_(at::Tensor & self); +TORCH_API at::Tensor asin_sparse_csr(const at::Tensor & self); +TORCH_API at::Tensor & asin_sparse_csr_out(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & asin_sparse_csr_(at::Tensor & self); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_not_compositeexplicitautogradnonfunctional_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_not_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6c370da3fa693bc313ddf97ffb48b696e5d36cd1 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_not_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor bitwise_not(const at::Tensor & self); +TORCH_API at::Tensor & bitwise_not_(at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_not_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_not_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..cf94c9e57d6d19a7bea8a2006c2ef250c837e765 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_not_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor bitwise_not(const at::Tensor & self); +TORCH_API at::Tensor & bitwise_not_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & bitwise_not_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & bitwise_not_(at::Tensor & self); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/coalesce_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/coalesce_native.h new file mode 100644 index 0000000000000000000000000000000000000000..af68f94afafc483830f43d53b39ecd12ff8dffe2 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/coalesce_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor coalesce(const at::Tensor & self); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/copy_sparse_to_sparse_meta_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/copy_sparse_to_sparse_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..0d265cdf8cebe5545d3be048da6dd65d9299046e --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/copy_sparse_to_sparse_meta_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor & copy_sparse_to_sparse_(at::Tensor & self, const at::Tensor & src, bool non_blocking=false); + +} // namespace meta +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_convolution.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_convolution.h new file mode 100644 index 0000000000000000000000000000000000000000..14eecf8a8ac45b5b728220dfccfe48d60247241b --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_convolution.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::cudnn_convolution(Tensor self, Tensor weight, int[] padding, int[] stride, int[] dilation, int groups, bool benchmark, bool deterministic, bool allow_tf32) -> Tensor +inline at::Tensor cudnn_convolution(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) { + return at::_ops::cudnn_convolution::call(self, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32); +} + +// 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!) +inline at::Tensor & cudnn_convolution_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) { + return at::_ops::cudnn_convolution_out::call(self, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out); +} +// 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!) +inline at::Tensor & cudnn_convolution_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) { + return at::_ops::cudnn_convolution_out::call(self, weight, padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out); +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/dequantize_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/dequantize_native.h new file mode 100644 index 0000000000000000000000000000000000000000..8399a325c5ee5b36e3deca8fa33cf379ef0cc19c --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/dequantize_native.h @@ -0,0 +1,25 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & dequantize_self_out(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor dequantize_cpu_or_cuda(const at::Tensor & self); +TORCH_API at::Tensor dequantize_quantized(const at::Tensor & self); +TORCH_API void dequantize_tensors_out(at::TensorList tensors, at::TensorList out); +TORCH_API ::std::vector dequantize_tensors_quantized_cpu(at::TensorList tensors); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/dot_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/dot_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..5b1afbaf3fad2ce3d9412807d2725e44663d2471 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/dot_cuda_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor dot(const at::Tensor & self, const at::Tensor & tensor); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/embedding_renorm_compositeexplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/embedding_renorm_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..54c202e04152bfc601f178f0f4ca369f8470b21a --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/embedding_renorm_compositeexplicitautograd_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor embedding_renorm(const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type); +TORCH_API at::Tensor & embedding_renorm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type); +TORCH_API at::Tensor & embedding_renorm_outf(const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/fmin.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/fmin.h new file mode 100644 index 0000000000000000000000000000000000000000..b421e06a6b286494dc0d7e27b18fd31a6a831d1b --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/fmin.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::fmin(Tensor self, Tensor other) -> Tensor +inline at::Tensor fmin(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::fmin::call(self, other); +} + +// aten::fmin.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & fmin_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::fmin_out::call(self, other, out); +} +// aten::fmin.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & fmin_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::fmin_out::call(self, other, out); +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/gcd_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/gcd_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..25d9eeba2e135814d373f9046fb4fe472afa60bf --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/gcd_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor gcd(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & gcd_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & gcd_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & gcd_(at::Tensor & self, const at::Tensor & other); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/grid_sampler_2d_cpu_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/grid_sampler_2d_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d0a004abcf0d0559eea81053433c3dd147578455 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/grid_sampler_2d_cpu_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor grid_sampler_2d(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners); + +} // namespace cpu +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/hypot.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/hypot.h new file mode 100644 index 0000000000000000000000000000000000000000..589c8fea89cc8bf0a5eea98958f07fc311bd875e --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/hypot.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::hypot.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & hypot_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::hypot_out::call(self, other, out); +} +// aten::hypot.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & hypot_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::hypot_out::call(self, other, out); +} + +// aten::hypot(Tensor self, Tensor other) -> Tensor +inline at::Tensor hypot(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::hypot::call(self, other); +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/index_select_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/index_select_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..ac1dcb68bfe88a267b5014a6268e988d2234b421 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/index_select_compositeimplicitautograd_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor index_select(const at::Tensor & self, at::Dimname dim, const at::Tensor & index); +TORCH_API at::Tensor & index_select_out(at::Tensor & out, const at::Tensor & self, at::Dimname dim, const at::Tensor & index); +TORCH_API at::Tensor & index_select_outf(const at::Tensor & self, at::Dimname dim, const at::Tensor & index, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/isin.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/isin.h new file mode 100644 index 0000000000000000000000000000000000000000..068b8641c91d70525fdda2bf7e7574b85bc7d9ab --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/isin.h @@ -0,0 +1,67 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::isin.Tensor_Tensor_out(Tensor elements, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false) { + return at::_ops::isin_Tensor_Tensor_out::call(elements, test_elements, assume_unique, invert, out); +} +// aten::isin.Tensor_Tensor_out(Tensor elements, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & isin_outf(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out) { + return at::_ops::isin_Tensor_Tensor_out::call(elements, test_elements, assume_unique, invert, out); +} + +// aten::isin.Tensor_Tensor(Tensor elements, Tensor test_elements, *, bool assume_unique=False, bool invert=False) -> Tensor +inline at::Tensor isin(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false) { + return at::_ops::isin_Tensor_Tensor::call(elements, test_elements, assume_unique, invert); +} + +// aten::isin.Tensor_Scalar_out(Tensor elements, Scalar test_element, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique=false, bool invert=false) { + return at::_ops::isin_Tensor_Scalar_out::call(elements, test_element, assume_unique, invert, out); +} +// aten::isin.Tensor_Scalar_out(Tensor elements, Scalar test_element, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & isin_outf(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert, at::Tensor & out) { + return at::_ops::isin_Tensor_Scalar_out::call(elements, test_element, assume_unique, invert, out); +} + +// aten::isin.Tensor_Scalar(Tensor elements, Scalar test_element, *, bool assume_unique=False, bool invert=False) -> Tensor +inline at::Tensor isin(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique=false, bool invert=false) { + return at::_ops::isin_Tensor_Scalar::call(elements, test_element, assume_unique, invert); +} + +// aten::isin.Scalar_Tensor_out(Scalar element, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & isin_out(at::Tensor & out, const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false) { + return at::_ops::isin_Scalar_Tensor_out::call(element, test_elements, assume_unique, invert, out); +} +// aten::isin.Scalar_Tensor_out(Scalar element, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & isin_outf(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out) { + return at::_ops::isin_Scalar_Tensor_out::call(element, test_elements, assume_unique, invert, out); +} + +// aten::isin.Scalar_Tensor(Scalar element, Tensor test_elements, *, bool assume_unique=False, bool invert=False) -> Tensor +inline at::Tensor isin(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false) { + return at::_ops::isin_Scalar_Tensor::call(element, test_elements, assume_unique, invert); +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log10_compositeexplicitautogradnonfunctional_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log10_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..1731b779f5d1c4f550daefc6c9ca4c504ea4b408 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log10_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor log10(const at::Tensor & self); +TORCH_API at::Tensor & log10_(at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log10_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log10_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..2a5a4ed2cd42bb566686587854c7db097215ff0e --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log10_ops.h @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API log10 { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log10") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log10(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API log10_ { + using schema = at::Tensor & (at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log10_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log10_(Tensor(a!) self) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self); +}; + +struct TORCH_API log10_out { + using schema = at::Tensor & (const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::log10") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "log10.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log2_compositeexplicitautogradnonfunctional_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log2_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..0c3163a4ff9fd5eb0c470e199be0f7aec2fb4f50 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log2_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor log2(const at::Tensor & self); +TORCH_API at::Tensor & log2_(at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log_compositeexplicitautogradnonfunctional_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..1bc9b581a0a6d19e3523246a6a11aaa72bdeb416 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/log_compositeexplicitautogradnonfunctional_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor log(const at::Tensor & self); +TORCH_API at::Tensor & log_(at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/matrix_exp_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/matrix_exp_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..e0588d0e3d873f0894e9fbbb4cab0672b15bc9b4 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/matrix_exp_ops.h @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API matrix_exp { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::matrix_exp") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "matrix_exp(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/max_unpool3d_cpu_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/max_unpool3d_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..c318f326c9a8d8e04a8faf42e7a5aa30ea283a12 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/max_unpool3d_cpu_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor max_unpool3d(const at::Tensor & self, const at::Tensor & indices, at::IntArrayRef output_size, at::IntArrayRef stride, at::IntArrayRef padding); +TORCH_API at::Tensor & max_unpool3d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & indices, at::IntArrayRef output_size, at::IntArrayRef stride, at::IntArrayRef padding); +TORCH_API at::Tensor & max_unpool3d_outf(const at::Tensor & self, const at::Tensor & indices, at::IntArrayRef output_size, at::IntArrayRef stride, at::IntArrayRef padding, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_linear_compositeexplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_linear_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..cbc76a31f8ceecc7a8a187e342786bd759cde090 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_linear_compositeexplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & mkldnn_linear_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias={}); +TORCH_API at::Tensor & mkldnn_linear_outf(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/native_layer_norm_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/native_layer_norm_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..87e7de159a773b419decbf4fc7c1769c088f8162 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/native_layer_norm_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API native_layer_norm { + using schema = ::std::tuple (const at::Tensor &, c10::SymIntArrayRef, const c10::optional &, const c10::optional &, double); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::native_layer_norm") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "native_layer_norm(Tensor input, SymInt[] normalized_shape, Tensor? weight, Tensor? bias, float eps) -> (Tensor, Tensor, Tensor)") + static ::std::tuple call(const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const c10::optional & weight, const c10::optional & bias, double eps); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const c10::optional & weight, const c10::optional & bias, double eps); +}; + +struct TORCH_API native_layer_norm_out { + using schema = ::std::tuple (const at::Tensor &, c10::SymIntArrayRef, const c10::optional &, const c10::optional &, double, at::Tensor &, at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::native_layer_norm") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "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!))") + static ::std::tuple call(const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const c10::optional & weight, const c10::optional & bias, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const c10::optional & weight, const c10::optional & bias, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/negative_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/negative_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..2cbf842bbd0825a9f0ec4574ad7f0d066f6b0881 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/negative_ops.h @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API negative { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::negative") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "negative(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API negative_ { + using schema = at::Tensor & (at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::negative_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "negative_(Tensor(a!) self) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self); +}; + +struct TORCH_API negative_out { + using schema = at::Tensor & (const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::negative") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "negative.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/nextafter_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/nextafter_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..02645788b0b8eebe115c6b41a78f7553b4ad7e7c --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/nextafter_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor nextafter(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & nextafter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & nextafter_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & nextafter_(at::Tensor & self, const at::Tensor & other); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/pad_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/pad_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9deb2d792d4fdcec11390527b29227befde71100 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/pad_compositeimplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor pad(const at::Tensor & self, at::IntArrayRef pad, c10::string_view mode="constant", c10::optional value=c10::nullopt); +TORCH_API at::Tensor pad_symint(const at::Tensor & self, c10::SymIntArrayRef pad, c10::string_view mode="constant", c10::optional value=c10::nullopt); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/quantize_per_channel_compositeexplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/quantize_per_channel_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..31a0af12225f7005fa25632adee59ec645672429 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/quantize_per_channel_compositeexplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & quantize_per_channel_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype); +TORCH_API at::Tensor & quantize_per_channel_outf(const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/relu_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/relu_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..988962be84621ddfdc769578f98acca0309baa29 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/relu_cuda_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor relu(const at::Tensor & self); +TORCH_API at::Tensor & relu_(at::Tensor & self); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/repeat.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/repeat.h new file mode 100644 index 0000000000000000000000000000000000000000..cb79b80ff5f6ad27d35ce787b1619d1e07c53583 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/repeat.h @@ -0,0 +1,83 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +namespace symint { + template ::value>> + at::Tensor repeat(const at::Tensor & self, at::IntArrayRef repeats) { + return at::_ops::repeat::call(self, c10::fromIntArrayRefSlow(repeats)); + } +} + +namespace symint { + template ::value>> + at::Tensor repeat(const at::Tensor & self, c10::SymIntArrayRef repeats) { + return at::_ops::repeat::call(self, repeats); + } +} + +// aten::repeat.out(Tensor self, SymInt[] repeats, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & repeat_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef repeats) { + return at::_ops::repeat_out::call(self, c10::fromIntArrayRefSlow(repeats), out); +} +namespace symint { + template ::value>> + at::Tensor & repeat_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef repeats) { + return at::_ops::repeat_out::call(self, c10::fromIntArrayRefSlow(repeats), out); + } +} + +// aten::repeat.out(Tensor self, SymInt[] repeats, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & repeat_outf(const at::Tensor & self, at::IntArrayRef repeats, at::Tensor & out) { + return at::_ops::repeat_out::call(self, c10::fromIntArrayRefSlow(repeats), out); +} +namespace symint { + template ::value>> + at::Tensor & repeat_outf(const at::Tensor & self, at::IntArrayRef repeats, at::Tensor & out) { + return at::_ops::repeat_out::call(self, c10::fromIntArrayRefSlow(repeats), out); + } +} + +// aten::repeat.out(Tensor self, SymInt[] repeats, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & repeat_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef repeats) { + return at::_ops::repeat_out::call(self, repeats, out); +} +namespace symint { + template ::value>> + at::Tensor & repeat_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef repeats) { + return at::_ops::repeat_out::call(self, repeats, out); + } +} + +// aten::repeat.out(Tensor self, SymInt[] repeats, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & repeat_symint_outf(const at::Tensor & self, c10::SymIntArrayRef repeats, at::Tensor & out) { + return at::_ops::repeat_out::call(self, repeats, out); +} +namespace symint { + template ::value>> + at::Tensor & repeat_outf(const at::Tensor & self, c10::SymIntArrayRef repeats, at::Tensor & out) { + return at::_ops::repeat_out::call(self, repeats, out); + } +} + +} diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/replication_pad3d_backward_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/replication_pad3d_backward_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..608763284f8db350b9677e6e5ebb6e401fd1cca2 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/replication_pad3d_backward_cuda_dispatch.h @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor replication_pad3d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor replication_pad3d_backward_symint(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & replication_pad3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor & replication_pad3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::Tensor & grad_input); +TORCH_API at::Tensor & replication_pad3d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & replication_pad3d_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & grad_input); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_tanh_cell_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_tanh_cell_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..b4186ec6a6f2e8afec9ffcd4ac339fd8c69ef87d --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_tanh_cell_compositeimplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor rnn_tanh_cell(const at::Tensor & input, const at::Tensor & hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const c10::optional & b_ih={}, const c10::optional & b_hh={}); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/scatter_add_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/scatter_add_native.h new file mode 100644 index 0000000000000000000000000000000000000000..9b4d0d1ed791f886b568f2a2fb18c53bc80af67c --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/scatter_add_native.h @@ -0,0 +1,24 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_scatter_add : public at::meta::structured_scatter_add { +void impl(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, const at::Tensor & out); +}; +TORCH_API at::Tensor scatter_add(const at::Tensor & self, at::Dimname dim, const at::Tensor & index, const at::Tensor & src); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/set_data_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/set_data_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..75bd3918d34372b03e98b9fd87e0add9462c03a4 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/set_data_compositeimplicitautograd_dispatch.h @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API void set_data(at::Tensor & self, const at::Tensor & new_data); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/sigmoid_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/sigmoid_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6b78740a4273630a4ce3f98bc77b04ad267b35cf --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/sigmoid_cuda_dispatch.h @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor sigmoid(const at::Tensor & self); +TORCH_API at::Tensor & sigmoid_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & sigmoid_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & sigmoid_(at::Tensor & self); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/sinh_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/sinh_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..620dd3533f039b353694f20b084dc2079fcad2e0 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/sinh_ops.h @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API sinh { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sinh") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sinh(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +struct TORCH_API sinh_ { + using schema = at::Tensor & (at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sinh_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sinh_(Tensor(a!) self) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self); +}; + +struct TORCH_API sinh_out { + using schema = at::Tensor & (const at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sinh") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_j0_meta.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_j0_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..0cc31f797435a5750487a6820a84833e8da951cf --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_j0_meta.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_special_bessel_j0 : public TensorIteratorBase { + + + void meta(const at::Tensor & self); +}; + +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_j1_cuda_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_j1_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3f2806edb8eda61529f9f3311d43f98a76c16c41 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_j1_cuda_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor special_bessel_j1(const at::Tensor & self); +TORCH_API at::Tensor & special_bessel_j1_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & special_bessel_j1_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_y0_cpu_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_y0_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..6428bcd109a146b95815f99e447d6a65ac73eed3 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_bessel_y0_cpu_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor special_bessel_y0(const at::Tensor & self); +TORCH_API at::Tensor & special_bessel_y0_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & special_bessel_y0_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_psi_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_psi_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..8933a587ec92fac30742fd3a3586c83dc2aa13bd --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_psi_compositeimplicitautograd_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor special_psi(const at::Tensor & self); +TORCH_API at::Tensor & special_psi_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & special_psi_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_native.h new file mode 100644 index 0000000000000000000000000000000000000000..a8f81f11627c244d416819c35fe93d745035db4e --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_shifted_chebyshev_polynomial_u_native.h @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_special_shifted_chebyshev_polynomial_u_out : public at::meta::structured_special_shifted_chebyshev_polynomial_u { +void impl(const at::Tensor & x, const at::Tensor & n, const at::Tensor & out); +}; +TORCH_API at::Tensor special_shifted_chebyshev_polynomial_u(const at::Scalar & x, const at::Tensor & n); +TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_u_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out); +TORCH_API at::Tensor special_shifted_chebyshev_polynomial_u(const at::Tensor & x, const at::Scalar & n); +TORCH_API at::Tensor & special_shifted_chebyshev_polynomial_u_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/split_copy_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/split_copy_native.h new file mode 100644 index 0000000000000000000000000000000000000000..d3c8fb1cfe7f70648cf268b7296fa815dbfd71bf --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/split_copy_native.h @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API void split_copy_Tensor_out(const at::Tensor & self, int64_t split_size, int64_t dim, at::TensorList out); +TORCH_API ::std::vector split_copy_Tensor_symint(const at::Tensor & self, c10::SymInt split_size, int64_t dim=0); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/std_cpu_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/std_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..dee57207a94b1f0e635da6bbb22c657089ad953a --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/std_cpu_dispatch.h @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor std(const at::Tensor & self, at::OptionalIntArrayRef dim=c10::nullopt, c10::optional correction=c10::nullopt, bool keepdim=false); +TORCH_API at::Tensor & std_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim=c10::nullopt, c10::optional correction=c10::nullopt, bool keepdim=false); +TORCH_API at::Tensor & std_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, c10::optional correction, bool keepdim, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/triangular_solve_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/triangular_solve_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..824ad9b94f95cf2b4f9e204e8e28d9e6d26efafb --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/triangular_solve_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API triangular_solve_X { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, bool, at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::triangular_solve") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "X") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "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)") + static ::std::tuple call(const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular, at::Tensor & X, at::Tensor & M); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular, at::Tensor & X, at::Tensor & M); +}; + +struct TORCH_API triangular_solve { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, bool, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::triangular_solve") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "triangular_solve(Tensor self, Tensor A, bool upper=True, bool transpose=False, bool unitriangular=False) -> (Tensor solution, Tensor cloned_coefficient)") + static ::std::tuple call(const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/type_as_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/type_as_native.h new file mode 100644 index 0000000000000000000000000000000000000000..ce295606e9b731f353d52f7c3f09dfcd612c417a --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/type_as_native.h @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor type_as(const at::Tensor & self, const at::Tensor & other); +} // namespace native +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unflatten_compositeimplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unflatten_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..0b7996b5a207c2a93eb8abca0d5e901b8909a19b --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unflatten_compositeimplicitautograd_dispatch.h @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor unflatten(const at::Tensor & self, int64_t dim, at::IntArrayRef sizes); +TORCH_API at::Tensor unflatten(const at::Tensor & self, at::Dimname dim, at::IntArrayRef sizes, at::DimnameList names); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unsafe_split_compositeexplicitautograd_dispatch.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unsafe_split_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..d153a4ac2f8b3fbaab972c6b98d258fec8900331 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unsafe_split_compositeexplicitautograd_dispatch.h @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API ::std::vector unsafe_split(const at::Tensor & self, int64_t split_size, int64_t dim=0); +TORCH_API ::std::vector unsafe_split_symint(const at::Tensor & self, c10::SymInt split_size, int64_t dim=0); +TORCH_API void unsafe_split_out(at::TensorList out, const at::Tensor & self, int64_t split_size, int64_t dim=0); +TORCH_API void unsafe_split_outf(const at::Tensor & self, int64_t split_size, int64_t dim, at::TensorList out); +TORCH_API void unsafe_split_symint_out(at::TensorList out, const at::Tensor & self, c10::SymInt split_size, int64_t dim=0); +TORCH_API void unsafe_split_symint_outf(const at::Tensor & self, c10::SymInt split_size, int64_t dim, at::TensorList out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unsqueeze_copy_ops.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unsqueeze_copy_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..ee985f3e5eee10b25642e05bd885f11d7face79e --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/unsqueeze_copy_ops.h @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API unsqueeze_copy { + using schema = at::Tensor (const at::Tensor &, int64_t); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::unsqueeze_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "unsqueeze_copy(Tensor self, int dim) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t dim); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim); +}; + +struct TORCH_API unsqueeze_copy_out { + using schema = at::Tensor & (const at::Tensor &, int64_t, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::unsqueeze_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "unsqueeze_copy.out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, int64_t dim, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/where_native.h b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/where_native.h new file mode 100644 index 0000000000000000000000000000000000000000..4a71c3a3fe900e30a3b7e890e916a5ad22616a32 --- /dev/null +++ b/openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/where_native.h @@ -0,0 +1,26 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor where(const at::Tensor & condition, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & where_self_out(const at::Tensor & condition, const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor where(const at::Tensor & condition, const at::Scalar & self, const at::Tensor & other); +TORCH_API at::Tensor where(const at::Tensor & condition, const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor where(const at::Tensor & condition, const at::Scalar & self, const at::Scalar & other); +TORCH_API ::std::vector where(const at::Tensor & condition); +} // namespace native +} // namespace at diff --git a/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/fake_quantize.cpython-310.pyc b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/fake_quantize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0d70a9eaed13ef5ff6c922b282bc4d2389cfde0 Binary files /dev/null and b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/fake_quantize.cpython-310.pyc differ diff --git a/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/fuse_modules.cpython-310.pyc b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/fuse_modules.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c777b7f10a3dbedad452e20503c8079df516ff3 Binary files /dev/null and b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/fuse_modules.cpython-310.pyc differ diff --git a/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quant_type.cpython-310.pyc b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quant_type.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bcce1eae11694c44865ffa4da5a05b347104617e Binary files /dev/null and b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quant_type.cpython-310.pyc differ diff --git a/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantization_mappings.cpython-310.pyc b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantization_mappings.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5768310ca8692c77bcbc0ab6d51ce966a3df2551 Binary files /dev/null and b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantization_mappings.cpython-310.pyc differ diff --git a/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantize.cpython-310.pyc b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36e5e5baba36deefd2e8c0d7d49dc3f22d22b1fd Binary files /dev/null and b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantize.cpython-310.pyc differ diff --git a/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantize_fx.cpython-310.pyc b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantize_fx.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9541ac660e61e2295b530cdcf9a2ea14b7df2a8f Binary files /dev/null and b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/quantize_fx.cpython-310.pyc differ diff --git a/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/stubs.cpython-310.pyc b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/stubs.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ca1cd89c9e94c2af8038cebaacf3f7643df55d3 Binary files /dev/null and b/phi4/lib/python3.10/site-packages/torch/quantization/__pycache__/stubs.cpython-310.pyc differ