diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cast_Half_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cast_Half_native.h new file mode 100644 index 0000000000000000000000000000000000000000..c8c6859b04d4fc067381c61c6ff6eb3586705759 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cast_Half_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 _cast_Half(const at::Tensor & self, bool non_blocking=false); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9bbf3531834c870b8d7558ba42a18ec5f029547a --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_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 & _embedding_bag_per_sample_weights_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx=-1); +TORCH_API at::Tensor & _embedding_bag_per_sample_weights_backward_outf(const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_native.h new file mode 100644 index 0000000000000000000000000000000000000000..b3390a2382e6a69f997f2fbf786319aae6954fce --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_embedding_bag_per_sample_weights_backward_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 & _embedding_bag_per_sample_weights_backward_out(const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx, at::Tensor & out); +TORCH_API at::Tensor _embedding_bag_per_sample_weights_backward_cpu(const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx=-1); +TORCH_API at::Tensor _embedding_bag_per_sample_weights_backward_cuda(const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx=-1); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..dc8494ef3b1449843abe714aa2064f8fa15ef8f1 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fake_quantize_learnable_per_channel_affine_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 _fake_quantize_learnable_per_channel_affine(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); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fft_c2c.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fft_c2c.h new file mode 100644 index 0000000000000000000000000000000000000000..c8c2382ed20bcf9be7df6c9da6e57b2a343d3560 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fft_c2c.h @@ -0,0 +1,91 @@ +#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::_fft_c2c(Tensor self, SymInt[] dim, int normalization, bool forward) -> Tensor +inline at::Tensor _fft_c2c(const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c::call(self, c10::fromIntArrayRefSlow(dim), normalization, forward); +} +namespace symint { + template ::value>> + at::Tensor _fft_c2c(const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c::call(self, c10::fromIntArrayRefSlow(dim), normalization, forward); + } +} + +// aten::_fft_c2c(Tensor self, SymInt[] dim, int normalization, bool forward) -> Tensor +inline at::Tensor _fft_c2c_symint(const at::Tensor & self, c10::SymIntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c::call(self, dim, normalization, forward); +} +namespace symint { + template ::value>> + at::Tensor _fft_c2c(const at::Tensor & self, c10::SymIntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c::call(self, dim, normalization, forward); + } +} + +// aten::_fft_c2c.out(Tensor self, SymInt[] dim, int normalization, bool forward, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _fft_c2c_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c_out::call(self, c10::fromIntArrayRefSlow(dim), normalization, forward, out); +} +namespace symint { + template ::value>> + at::Tensor & _fft_c2c_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c_out::call(self, c10::fromIntArrayRefSlow(dim), normalization, forward, out); + } +} + +// aten::_fft_c2c.out(Tensor self, SymInt[] dim, int normalization, bool forward, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _fft_c2c_outf(const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool forward, at::Tensor & out) { + return at::_ops::_fft_c2c_out::call(self, c10::fromIntArrayRefSlow(dim), normalization, forward, out); +} +namespace symint { + template ::value>> + at::Tensor & _fft_c2c_outf(const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool forward, at::Tensor & out) { + return at::_ops::_fft_c2c_out::call(self, c10::fromIntArrayRefSlow(dim), normalization, forward, out); + } +} + +// aten::_fft_c2c.out(Tensor self, SymInt[] dim, int normalization, bool forward, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _fft_c2c_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c_out::call(self, dim, normalization, forward, out); +} +namespace symint { + template ::value>> + at::Tensor & _fft_c2c_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef dim, int64_t normalization, bool forward) { + return at::_ops::_fft_c2c_out::call(self, dim, normalization, forward, out); + } +} + +// aten::_fft_c2c.out(Tensor self, SymInt[] dim, int normalization, bool forward, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & _fft_c2c_symint_outf(const at::Tensor & self, c10::SymIntArrayRef dim, int64_t normalization, bool forward, at::Tensor & out) { + return at::_ops::_fft_c2c_out::call(self, dim, normalization, forward, out); +} +namespace symint { + template ::value>> + at::Tensor & _fft_c2c_outf(const at::Tensor & self, c10::SymIntArrayRef dim, int64_t normalization, bool forward, at::Tensor & out) { + return at::_ops::_fft_c2c_out::call(self, dim, normalization, forward, out); + } +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fft_r2c_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fft_r2c_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..e8603350dd69505e4a40bd9214457a62f6d550ee --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_fft_r2c_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 _fft_r2c { + using schema = at::Tensor (const at::Tensor &, at::IntArrayRef, int64_t, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_fft_r2c") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_fft_r2c(Tensor self, int[] dim, int normalization, bool onesided) -> Tensor") + static at::Tensor call(const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool onesided); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool onesided); +}; + +struct TORCH_API _fft_r2c_out { + using schema = at::Tensor & (const at::Tensor &, at::IntArrayRef, int64_t, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_fft_r2c") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_fft_r2c.out(Tensor self, int[] dim, int normalization, bool onesided, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool onesided, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, int64_t normalization, bool onesided, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foobar_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foobar_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..b599e69578952940cc167aaeb4b109a1de870520 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foobar_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 _foobar { + using schema = 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::_foobar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foobar(Tensor self, bool arg1=True, bool arg2=True, *, bool arg3=True) -> Tensor") + static at::Tensor call(const at::Tensor & self, bool arg1, bool arg2, bool arg3); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, bool arg1, bool arg2, bool arg3); +}; + +struct TORCH_API _foobar_out { + using schema = at::Tensor & (const at::Tensor &, bool, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foobar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foobar.out(Tensor self, bool arg1=True, bool arg2=True, *, bool arg3=True, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, bool arg1, bool arg2, bool arg3, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, bool arg1, bool arg2, bool arg3, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_tanh.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_tanh.h new file mode 100644 index 0000000000000000000000000000000000000000..93e5f0bb4fc85259eaab9942283936b438595fdf --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_foreach_tanh.h @@ -0,0 +1,44 @@ +#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::_foreach_tanh(Tensor[] self) -> Tensor[] +inline ::std::vector _foreach_tanh(at::TensorList self) { + return at::_ops::_foreach_tanh::call(self); +} + +// aten::_foreach_tanh_(Tensor(a!)[] self) -> () +inline void _foreach_tanh_(at::TensorList self) { + return at::_ops::_foreach_tanh_::call(self); +} + +// aten::_foreach_tanh.out(Tensor[] self, *, Tensor(a!)[] out) -> () +inline void _foreach_tanh_out(at::TensorList out, at::TensorList self) { + return at::_ops::_foreach_tanh_out::call(self, out); +} +// aten::_foreach_tanh.out(Tensor[] self, *, Tensor(a!)[] out) -> () +inline void _foreach_tanh_outf(at::TensorList self, at::TensorList out) { + return at::_ops::_foreach_tanh_out::call(self, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_det_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_det_native.h new file mode 100644 index 0000000000000000000000000000000000000000..4eeee9e3b1467a1e7dc86a8892f7ed1d6957b204 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_linalg_det_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 +#include + +namespace at { +namespace native { +struct TORCH_API structured__linalg_det_out : public at::meta::structured__linalg_det { +void impl(const at::Tensor & A, const at::Tensor & result, const at::Tensor & LU, const at::Tensor & pivots); +}; +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_make_dual_copy_compositeexplicitautogradnonfunctional_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_make_dual_copy_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..ad6574998fcfc31b4c792838570ecb3b9d87791a --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_make_dual_copy_compositeexplicitautogradnonfunctional_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 compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor _make_dual_copy(const at::Tensor & primal, const at::Tensor & tangent, int64_t level); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_mixed_dtypes_linear_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_mixed_dtypes_linear_native.h new file mode 100644 index 0000000000000000000000000000000000000000..2d85eed9b0873a13e775973fdcff7a4ac04be929 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_mixed_dtypes_linear_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 _mixed_dtypes_linear(const at::Tensor & input, const at::Tensor & weight, const at::Tensor & scale, const c10::optional & bias={}, c10::optional activation=c10::nullopt); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_pdist_backward_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_pdist_backward_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..e5c98a361604ee2b37fba4c04409e88335f44a23 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_pdist_backward_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 _pdist_backward(const at::Tensor & grad, const at::Tensor & self, double p, const at::Tensor & pdist); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_dot_product_efficient_attention_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_dot_product_efficient_attention_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..28eec721e84b0a1355ec708aee24e680a50b5797 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_scaled_dot_product_efficient_attention_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 ::std::tuple _scaled_dot_product_efficient_attention(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const c10::optional & attn_bias, bool compute_log_sumexp, double dropout_p=0.0, bool is_causal=false, c10::optional scale=c10::nullopt); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_sum_backward_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_sum_backward_native.h new file mode 100644 index 0000000000000000000000000000000000000000..70bf2d16432e36ffee4ec288f10648b7eb2c918d --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_sum_backward_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_sum_backward_out(const at::Tensor & grad, const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out); +TORCH_API at::Tensor _sparse_sum_backward_cpu(const at::Tensor & grad, const at::Tensor & self, at::IntArrayRef dim); +TORCH_API at::Tensor _sparse_sum_backward_cuda(const at::Tensor & grad, const at::Tensor & self, at::IntArrayRef dim); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_sum_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_sum_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..d4d73a86f7699930e471a193545016ce990ec9ee --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_sparse_sum_ops.h @@ -0,0 +1,72 @@ +#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 _sparse_sum { + 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::_sparse_sum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_sum(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 _sparse_sum_dtype { + using schema = at::Tensor (const at::Tensor &, at::ScalarType); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_sparse_sum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dtype") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_sum.dtype(Tensor self, *, ScalarType dtype) -> Tensor") + static at::Tensor call(const at::Tensor & self, at::ScalarType dtype); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::ScalarType dtype); +}; + +struct TORCH_API _sparse_sum_dim { + using schema = at::Tensor (const at::Tensor &, at::IntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_sparse_sum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_sum.dim(Tensor self, int[1] dim) -> Tensor") + static at::Tensor call(const at::Tensor & self, at::IntArrayRef dim); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim); +}; + +struct TORCH_API _sparse_sum_dim_dtype { + using schema = at::Tensor (const at::Tensor &, at::IntArrayRef, at::ScalarType); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_sparse_sum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim_dtype") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_sum.dim_dtype(Tensor self, int[1] dim, *, ScalarType dtype) -> Tensor") + static at::Tensor call(const at::Tensor & self, at::IntArrayRef dim, at::ScalarType dtype); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, at::ScalarType dtype); +}; + +struct TORCH_API _sparse_sum_dim_out { + using schema = at::Tensor & (const at::Tensor &, at::IntArrayRef, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_sparse_sum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dim_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_sparse_sum.dim_out(Tensor self, int[1] dim, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_ambiguous_defaults_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_ambiguous_defaults_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..1229fda9e74dfcc2fe71059dab2c240277dd64cd --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_ambiguous_defaults_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 _test_ambiguous_defaults_a { + using schema = at::Tensor (const at::Tensor &, int64_t, int64_t); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_test_ambiguous_defaults") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "a") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_test_ambiguous_defaults.a(Tensor dummy, int a=1, int b=1) -> Tensor") + static at::Tensor call(const at::Tensor & dummy, int64_t a, int64_t b); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & dummy, int64_t a, int64_t b); +}; + +struct TORCH_API _test_ambiguous_defaults_b { + using schema = at::Tensor (const at::Tensor &, int64_t, c10::string_view); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_test_ambiguous_defaults") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "b") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_test_ambiguous_defaults.b(Tensor dummy, int a=2, str b=\"2\") -> Tensor") + static at::Tensor call(const at::Tensor & dummy, int64_t a, c10::string_view b); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & dummy, int64_t a, c10::string_view b); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_optional_intlist_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_optional_intlist_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..5799d125ef94b3fd8cb9fb38fc7e2cf63e828f77 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_test_optional_intlist_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 & _test_optional_intlist_out(at::Tensor & out, const at::Tensor & values, at::OptionalIntArrayRef addends); +TORCH_API at::Tensor & _test_optional_intlist_outf(const at::Tensor & values, at::OptionalIntArrayRef addends, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_version.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_version.h new file mode 100644 index 0000000000000000000000000000000000000000..5ea648538e2fd8ba02f9fcd05a69b5f79086fda5 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_version.h @@ -0,0 +1,26 @@ +#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 { + + + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/arange_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/arange_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..b216d46c5c12c01792ed16eea3c05f9a72650693 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/arange_meta_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 meta { + +TORCH_API at::Tensor & arange_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, const at::Scalar & step); +TORCH_API at::Tensor & arange_outf(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/ccol_indices_copy_compositeexplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..639cbb5e134beb0826719fec7932496c7d5af524 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/ccol_indices_copy_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 & ccol_indices_copy_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & ccol_indices_copy_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9fc4959fa5491561f1955ceed7471dd36ccef9ac --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cholesky_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 cholesky(const at::Tensor & self, bool upper=false); +TORCH_API at::Tensor & cholesky_out(at::Tensor & out, const at::Tensor & self, bool upper=false); +TORCH_API at::Tensor & cholesky_outf(const at::Tensor & self, bool upper, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/clamp_min_meta.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/clamp_min_meta.h new file mode 100644 index 0000000000000000000000000000000000000000..4cdf87ce9bafb2f679216cbe14dbe050ad2a0db7 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/clamp_min_meta.h @@ -0,0 +1,32 @@ +#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_clamp_min : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Scalar & min); +}; +struct TORCH_API structured_clamp_min_Tensor : public TensorIteratorBase { + + + void meta(const at::Tensor & self, const at::Tensor & min); +}; + +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/contiguous_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/contiguous_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..cb3e7fb2aa9e185f819848aae4de4cf7a85f32a3 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/contiguous_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 contiguous(const at::Tensor & self, at::MemoryFormat memory_format=MemoryFormat::Contiguous); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_batch_norm_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_batch_norm_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..5e018c22f13f5629534c8c13405fc971d02d3358 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cudnn_batch_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 cudnn_batch_norm { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cudnn_batch_norm") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cudnn_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon) -> (Tensor, Tensor, Tensor, Tensor)") + static ::std::tuple call(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double exponential_average_factor, double epsilon); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double exponential_average_factor, double epsilon); +}; + +struct TORCH_API cudnn_batch_norm_out { + using schema = ::std::tuple (const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &, const c10::optional &, bool, double, double, at::Tensor &, at::Tensor &, at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cudnn_batch_norm") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cudnn_batch_norm.out(Tensor input, Tensor weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float exponential_average_factor, float epsilon, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!))") + static ::std::tuple call(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double exponential_average_factor, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, const c10::optional & running_mean, const c10::optional & running_var, bool training, double exponential_average_factor, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cumprod_backward_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cumprod_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..74e54910b0e1e4efe117c4b8ca6544e4712991ce --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cumprod_backward_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 cumprod_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, 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::cumprod_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cumprod_backward(Tensor grad, Tensor input, int dim, Tensor output) -> Tensor") + static at::Tensor call(const at::Tensor & grad, const at::Tensor & input, int64_t dim, const at::Tensor & output); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad, const at::Tensor & input, int64_t dim, const at::Tensor & output); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cumsum_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cumsum_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..ea2b1cda955de4d5e5798d1ca8748328603ed0cb --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/cumsum_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor cumsum(const at::Tensor & self, at::Dimname dim, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor & cumsum_out(at::Tensor & out, const at::Tensor & self, at::Dimname dim, c10::optional dtype=c10::nullopt); +TORCH_API at::Tensor & cumsum_outf(const at::Tensor & self, at::Dimname dim, c10::optional dtype, at::Tensor & out); +TORCH_API at::Tensor & cumsum_(at::Tensor & self, at::Dimname dim, c10::optional dtype=c10::nullopt); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/erfinv_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/erfinv_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..61d9d6579f355db68aa6b82c644006fe22af8bb9 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/erfinv_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 erfinv(const at::Tensor & self); +TORCH_API at::Tensor & erfinv_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & erfinv_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & erfinv_(at::Tensor & self); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/exp2_compositeexplicitautogradnonfunctional_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/exp2_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..c0f2c315108247cc974ba3dc0eb7c2b1ba493e1e --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/exp2_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 exp2(const at::Tensor & self); +TORCH_API at::Tensor & exp2_(at::Tensor & self); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/exp_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/exp_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..682ddfa2f71fc50165b3c0fd4ec20d9800c6a678 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/exp_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 exp(const at::Tensor & self); +TORCH_API at::Tensor & exp_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & exp_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & exp_(at::Tensor & self); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_channel_affine.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_channel_affine.h new file mode 100644 index 0000000000000000000000000000000000000000..d3aabb82c9a37db4669e2861e31407fd5532eed7 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_channel_affine.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_per_channel_affine(Tensor self, Tensor scale, Tensor zero_point, int axis, int quant_min, int quant_max) -> Tensor +inline at::Tensor fake_quantize_per_channel_affine(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max) { + return at::_ops::fake_quantize_per_channel_affine::call(self, scale, zero_point, axis, quant_min, quant_max); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_native.h new file mode 100644 index 0000000000000000000000000000000000000000..64b485b5b26b3301ad5eb4f7d1dc7c4a63809ea8 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_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 fake_quantize_per_tensor_affine_cachemask_backward(const at::Tensor & grad, const at::Tensor & mask); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ihfft2_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ihfft2_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9c8543bcba0ca5c16b969f51449f219a9d29c420 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ihfft2_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor fft_ihfft2(const at::Tensor & self, at::OptionalIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API at::Tensor fft_ihfft2_symint(const at::Tensor & self, at::OptionalSymIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API const at::Tensor & fft_ihfft2_out(const at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API const at::Tensor & fft_ihfft2_outf(const at::Tensor & self, at::OptionalIntArrayRef s, at::IntArrayRef dim, c10::optional norm, const at::Tensor & out); +TORCH_API const at::Tensor & fft_ihfft2_symint_out(const at::Tensor & out, const at::Tensor & self, at::OptionalSymIntArrayRef s=c10::nullopt, at::IntArrayRef dim={-2,-1}, c10::optional norm=c10::nullopt); +TORCH_API const at::Tensor & fft_ihfft2_symint_outf(const at::Tensor & self, at::OptionalSymIntArrayRef s, at::IntArrayRef dim, c10::optional norm, const at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ihfftn_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ihfftn_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..141b0b1941f99410efd6a343d6bdcf3c92c9fa49 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fft_ihfftn_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor fft_ihfftn(const at::Tensor & self, at::OptionalIntArrayRef s=c10::nullopt, at::OptionalIntArrayRef dim=c10::nullopt, c10::optional norm=c10::nullopt); +TORCH_API at::Tensor fft_ihfftn_symint(const at::Tensor & self, at::OptionalSymIntArrayRef s=c10::nullopt, at::OptionalIntArrayRef dim=c10::nullopt, c10::optional norm=c10::nullopt); +TORCH_API const at::Tensor & fft_ihfftn_out(const at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef s=c10::nullopt, at::OptionalIntArrayRef dim=c10::nullopt, c10::optional norm=c10::nullopt); +TORCH_API const at::Tensor & fft_ihfftn_outf(const at::Tensor & self, at::OptionalIntArrayRef s, at::OptionalIntArrayRef dim, c10::optional norm, const at::Tensor & out); +TORCH_API const at::Tensor & fft_ihfftn_symint_out(const at::Tensor & out, const at::Tensor & self, at::OptionalSymIntArrayRef s=c10::nullopt, at::OptionalIntArrayRef dim=c10::nullopt, c10::optional norm=c10::nullopt); +TORCH_API const at::Tensor & fft_ihfftn_symint_outf(const at::Tensor & self, at::OptionalSymIntArrayRef s, at::OptionalIntArrayRef dim, c10::optional norm, const at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fmax_compositeexplicitautogradnonfunctional_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fmax_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..9b539c92c5ead61c9c46e99e6041436f7aa24eb8 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/fmax_compositeexplicitautogradnonfunctional_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 compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor fmax(const at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/gcd_compositeexplicitautogradnonfunctional_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/gcd_compositeexplicitautogradnonfunctional_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..50918137f2522ff9cf22356afdadafa2f36843ca --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/gcd_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 gcd(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & gcd_(at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/index_put_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/index_put_native.h new file mode 100644 index 0000000000000000000000000000000000000000..8ecff044f5ef1dd8b7e23f2a67ca067d4e6d1b2b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/index_put_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 index_put(const at::Tensor & self, const c10::List> & indices, const at::Tensor & values, bool accumulate=false); +TORCH_API at::Tensor & index_put_out(const at::Tensor & self, const c10::List> & indices, const at::Tensor & values, bool accumulate, at::Tensor & out); +TORCH_API at::Tensor & index_put_(at::Tensor & self, const c10::List> & indices, const at::Tensor & values, bool accumulate=false); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isin_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isin_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..78ff202871c5ee01025a2783a0a48283b00090a9 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/isin_cuda_dispatch.h @@ -0,0 +1,31 @@ +#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 isin(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_outf(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); +TORCH_API at::Tensor isin(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_outf(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert, at::Tensor & out); +TORCH_API at::Tensor isin(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_out(at::Tensor & out, const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique=false, bool invert=false); +TORCH_API at::Tensor & isin_outf(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lstm_cell_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lstm_cell_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..d2b8eac109b20804ffb200e3322910ceb4e080d4 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lstm_cell_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 lstm_cell { + using schema = ::std::tuple (const at::Tensor &, at::TensorList, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::lstm_cell") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "lstm_cell(Tensor input, Tensor[] hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> (Tensor, Tensor)") + static ::std::tuple call(const at::Tensor & input, at::TensorList hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const c10::optional & b_ih, const c10::optional & b_hh); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, at::TensorList hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const c10::optional & b_ih, const c10::optional & b_hh); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lu_unpack_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lu_unpack_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..f70c74014fbb072a8f46bd552e1d17ec50720184 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lu_unpack_meta_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 meta { + +TORCH_API ::std::tuple lu_unpack(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data=true, bool unpack_pivots=true); +TORCH_API ::std::tuple lu_unpack_out(at::Tensor & P, at::Tensor & L, at::Tensor & U, const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data=true, bool unpack_pivots=true); +TORCH_API ::std::tuple lu_unpack_outf(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots, at::Tensor & P, at::Tensor & L, at::Tensor & U); + +} // namespace meta +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/masked_scatter.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/masked_scatter.h new file mode 100644 index 0000000000000000000000000000000000000000..b1725e41270dc52130b80688516299d4d4c26910 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/masked_scatter.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::masked_scatter(Tensor self, Tensor mask, Tensor source) -> Tensor +inline at::Tensor masked_scatter(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source) { + return at::_ops::masked_scatter::call(self, mask, source); +} + +// aten::masked_scatter.out(Tensor self, Tensor mask, Tensor source, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & masked_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source) { + return at::_ops::masked_scatter_out::call(self, mask, source, out); +} +// aten::masked_scatter.out(Tensor self, Tensor mask, Tensor source, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & masked_scatter_outf(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source, at::Tensor & out) { + return at::_ops::masked_scatter_out::call(self, mask, source, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/miopen_convolution_transpose_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/miopen_convolution_transpose_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..7dfa964e21613079df3cc971159abb1d66da4d44 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/miopen_convolution_transpose_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 miopen_convolution_transpose(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic); +TORCH_API at::Tensor miopen_convolution_transpose_symint(const at::Tensor & self, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_linear_backward_weights_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_linear_backward_weights_native.h new file mode 100644 index 0000000000000000000000000000000000000000..0bae829e9ce8532c642233056505a7ed4f91d66a --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/mkldnn_linear_backward_weights_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 ::std::tuple mkldnn_linear_backward_weights_out(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, bool bias_defined, at::Tensor & out0, at::Tensor & out1); +TORCH_API ::std::tuple mkldnn_linear_backward_weights(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, bool bias_defined); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_norm.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_norm.h new file mode 100644 index 0000000000000000000000000000000000000000..8c6fd8aa8ee1871406e7f1f9efca65aa6b574c9e --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_norm.h @@ -0,0 +1,53 @@ +#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::native_norm(Tensor self, Scalar p=2) -> Tensor +inline at::Tensor native_norm(const at::Tensor & self, const at::Scalar & p=2) { + return at::_ops::native_norm::call(self, p); +} + +// aten::native_norm.ScalarOpt_dim_dtype(Tensor self, Scalar? p, int[1] dim, bool keepdim, ScalarType? dtype) -> Tensor +inline at::Tensor native_norm(const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim, c10::optional dtype) { + return at::_ops::native_norm_ScalarOpt_dim_dtype::call(self, p, dim, keepdim, dtype); +} + +// aten::native_norm.out(Tensor self, Scalar p=2, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & native_norm_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & p=2) { + return at::_ops::native_norm_out::call(self, p, out); +} +// aten::native_norm.out(Tensor self, Scalar p=2, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & native_norm_outf(const at::Tensor & self, const at::Scalar & p, at::Tensor & out) { + return at::_ops::native_norm_out::call(self, p, out); +} + +// aten::native_norm.ScalarOpt_dim_dtype_out(Tensor self, Scalar? p, int[1] dim, bool keepdim, ScalarType? dtype, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & native_norm_out(at::Tensor & out, const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim, c10::optional dtype) { + return at::_ops::native_norm_ScalarOpt_dim_dtype_out::call(self, p, dim, keepdim, dtype, out); +} +// aten::native_norm.ScalarOpt_dim_dtype_out(Tensor self, Scalar? p, int[1] dim, bool keepdim, ScalarType? dtype, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & native_norm_outf(const at::Tensor & self, const c10::optional & p, at::IntArrayRef dim, bool keepdim, c10::optional dtype, at::Tensor & out) { + return at::_ops::native_norm_ScalarOpt_dim_dtype_out::call(self, p, dim, keepdim, dtype, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/ones_like.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/ones_like.h new file mode 100644 index 0000000000000000000000000000000000000000..1c423cc3c46ced01575079faf943c84a81ad835b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/ones_like.h @@ -0,0 +1,43 @@ +#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::ones_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor +inline at::Tensor ones_like(const at::Tensor & self, at::TensorOptions options={}, c10::optional memory_format=c10::nullopt) { + return at::_ops::ones_like::call(self, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format)); +} +// aten::ones_like(Tensor self, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None, MemoryFormat? memory_format=None) -> Tensor +inline at::Tensor ones_like(const at::Tensor & self, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory, c10::optional memory_format) { + return at::_ops::ones_like::call(self, dtype, layout, device, pin_memory, memory_format); +} + +// aten::ones_like.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & ones_like_out(at::Tensor & out, const at::Tensor & self, c10::optional memory_format=c10::nullopt) { + return at::_ops::ones_like_out::call(self, memory_format, out); +} +// aten::ones_like.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & ones_like_outf(const at::Tensor & self, c10::optional memory_format, at::Tensor & out) { + return at::_ops::ones_like_out::call(self, memory_format, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rand_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rand_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..7330c5fe351fb660425366c5b95c58cb1f9bae31 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rand_compositeimplicitautograd_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 compositeimplicitautograd { + +TORCH_API at::Tensor & rand_out(at::Tensor & out, at::IntArrayRef size, c10::optional generator); +TORCH_API at::Tensor & rand_outf(at::IntArrayRef size, c10::optional generator, at::Tensor & out); +TORCH_API at::Tensor & rand_symint_out(at::Tensor & out, c10::SymIntArrayRef size, c10::optional generator); +TORCH_API at::Tensor & rand_symint_outf(c10::SymIntArrayRef size, c10::optional generator, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/range.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/range.h new file mode 100644 index 0000000000000000000000000000000000000000..3cee7f5fdd859fc418ff2be67a43a1c02747249c --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/range.h @@ -0,0 +1,61 @@ +#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::range.step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor range(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step=1, at::TensorOptions options={}) { + return at::_ops::range_step::call(start, end, step, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::range.step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor range(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::range_step::call(start, end, step, dtype, layout, device, pin_memory); +} + +// aten::range(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor range(const at::Scalar & start, const at::Scalar & end, at::TensorOptions options={}) { + return at::_ops::range::call(start, end, optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::range(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor range(const at::Scalar & start, const at::Scalar & end, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::range::call(start, end, dtype, layout, device, pin_memory); +} + +// aten::range.out_(Scalar start, Scalar end, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & range_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end) { + return at::_ops::range_out_::call(start, end, out); +} +// aten::range.out_(Scalar start, Scalar end, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & range_outf(const at::Scalar & start, const at::Scalar & end, at::Tensor & out) { + return at::_ops::range_out_::call(start, end, out); +} + +// aten::range.out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & range_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, const at::Scalar & step) { + return at::_ops::range_out::call(start, end, step, out); +} +// aten::range.out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & range_outf(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out) { + return at::_ops::range_out::call(start, end, step, out); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reflection_pad2d_backward_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reflection_pad2d_backward_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..16a5b8377df319a25a29307b8d878b97dd1aa1af --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reflection_pad2d_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 reflection_pad2d_backward_grad_input { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, 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::reflection_pad2d_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "grad_input") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "reflection_pad2d_backward.grad_input(Tensor grad_output, Tensor self, SymInt[4] padding, *, Tensor(a!) grad_input) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & grad_input); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & grad_input); +}; + +struct TORCH_API reflection_pad2d_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::reflection_pad2d_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "reflection_pad2d_backward(Tensor grad_output, Tensor self, SymInt[4] padding) -> Tensor") + static at::Tensor call(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/remainder_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/remainder_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..3c6bcbfc97fb839cb850562c37df29668341c78c --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/remainder_cpu_dispatch.h @@ -0,0 +1,27 @@ +#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 remainder(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & remainder_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & remainder_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & remainder_(at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor remainder(const at::Scalar & self, const at::Tensor & other); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_tanh.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_tanh.h new file mode 100644 index 0000000000000000000000000000000000000000..f5c741ea7b3cdffb10a969f410c0a81617b8924c --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_tanh.h @@ -0,0 +1,35 @@ +#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::rnn_tanh.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor) +inline ::std::tuple rnn_tanh(const at::Tensor & input, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) { + return at::_ops::rnn_tanh_input::call(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first); +} + +// aten::rnn_tanh.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor) +inline ::std::tuple rnn_tanh(const at::Tensor & data, const at::Tensor & batch_sizes, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) { + return at::_ops::rnn_tanh_data::call(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slice_copy_native.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slice_copy_native.h new file mode 100644 index 0000000000000000000000000000000000000000..9103fb16eac2fa4474e21cb843bc646dc87b536b --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slice_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 at::Tensor & slice_copy_Tensor_out_symint(const at::Tensor & self, int64_t dim, c10::optional start, c10::optional end, c10::SymInt step, at::Tensor & out); +TORCH_API at::Tensor slice_copy_Tensor_symint(const at::Tensor & self, int64_t dim=0, c10::optional start=c10::nullopt, c10::optional end=c10::nullopt, c10::SymInt step=1); +} // namespace native +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv_dilated2d_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv_dilated2d_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..2faa6c605fe1030f66d48b853006c0d96818cb12 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slow_conv_dilated2d_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 slow_conv_dilated2d { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, const c10::optional &, c10::SymIntArrayRef, 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::slow_conv_dilated2d") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "slow_conv_dilated2d(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] dilation=1) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation); +}; + +struct TORCH_API slow_conv_dilated2d_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, const c10::optional &, c10::SymIntArrayRef, 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::slow_conv_dilated2d") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "slow_conv_dilated2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sparse_dim.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sparse_dim.h new file mode 100644 index 0000000000000000000000000000000000000000..92c1cd88fa3a0273bec256d98bd4eac3656843cf --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sparse_dim.h @@ -0,0 +1,26 @@ +#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 { + + + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sparse_resize_and_clear.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sparse_resize_and_clear.h new file mode 100644 index 0000000000000000000000000000000000000000..8d4b5cc3fcb8ebc2a8dbec8755c3d1b4e09fbc8d --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/sparse_resize_and_clear.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::sparse_resize_and_clear.out(Tensor self, int[] size, int sparse_dim, int dense_dim, *, Tensor(a!) out) -> Tensor(a!) +inline const at::Tensor & sparse_resize_and_clear_out(const at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) { + return at::_ops::sparse_resize_and_clear_out::call(self, size, sparse_dim, dense_dim, out); +} +// aten::sparse_resize_and_clear.out(Tensor self, int[] size, int sparse_dim, int dense_dim, *, Tensor(a!) out) -> Tensor(a!) +inline const at::Tensor & sparse_resize_and_clear_outf(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out) { + return at::_ops::sparse_resize_and_clear_out::call(self, size, sparse_dim, dense_dim, out); +} + +// aten::sparse_resize_and_clear(Tensor self, int[] size, int sparse_dim, int dense_dim) -> Tensor +inline at::Tensor sparse_resize_and_clear(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) { + return at::_ops::sparse_resize_and_clear::call(self, size, sparse_dim, dense_dim); +} + +} diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_log1p_compositeimplicitautograd_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_log1p_compositeimplicitautograd_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..8fa322c8682ec33497f80df70b99b45ee112ac1d --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_log1p_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_log1p(const at::Tensor & self); +TORCH_API at::Tensor & special_log1p_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & special_log1p_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_modified_bessel_k1_cpu_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_modified_bessel_k1_cpu_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..37874557bb2d137e985714ec722e6e041e6816bd --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_modified_bessel_k1_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_modified_bessel_k1(const at::Tensor & self); +TORCH_API at::Tensor & special_modified_bessel_k1_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & special_modified_bessel_k1_outf(const at::Tensor & self, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/t_copy_ops.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/t_copy_ops.h new file mode 100644 index 0000000000000000000000000000000000000000..6a17431bca56efdd5c9a32ef140839760e070546 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/t_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 t_copy { + 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::t_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "t_copy(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 t_copy_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::t_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "t_copy.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/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/uniform_cuda_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/uniform_cuda_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..4919a090b4b0dd33001c856e3b9104c187e1a8cb --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/uniform_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 & uniform_(at::Tensor & self, double from=0, double to=1, c10::optional generator=c10::nullopt); + +} // namespace cuda +} // namespace at diff --git a/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_nearest3d_meta_dispatch.h b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_nearest3d_meta_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..86f5d0442a6086a7122816b6065b107d9d91ecc3 --- /dev/null +++ b/videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/upsample_nearest3d_meta_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 meta { + +TORCH_API at::Tensor upsample_nearest3d(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor upsample_nearest3d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_nearest3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_nearest3d_outf(const at::Tensor & self, at::IntArrayRef output_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & out); +TORCH_API at::Tensor & upsample_nearest3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & upsample_nearest3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & out); + +} // namespace meta +} // namespace at diff --git a/vllm/lib/python3.10/site-packages/ray/__pycache__/_version.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/__pycache__/_version.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10eae959d83126cc13966890b37c6c978db902ad Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/__pycache__/_version.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/__pycache__/actor.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/__pycache__/actor.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6830782ec7c53e69ade45f7e6df0ca1d709c3028 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/__pycache__/actor.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/__pycache__/client_builder.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/__pycache__/client_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41763f8759927c6356144b7b72a03caa4ab3d2a0 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/__pycache__/client_builder.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/__pycache__/exceptions.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/__pycache__/exceptions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0fec11cf265830ea84fe8681d46e5a00488d54a9 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/__pycache__/exceptions.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/__pycache__/job_config.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/__pycache__/job_config.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15fea04dca5c7d879ac932511aedeafb5ad0f7a0 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/__pycache__/job_config.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/__pycache__/types.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/__pycache__/types.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ff0a3b10cb5b1cc24f4cffbbdb5159bca8b68a3 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/__pycache__/types.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17b7e58968213a811990b6f78b402a8fb1b3e589 Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/__init__.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/usage_constants.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/usage_constants.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..942cf7aa643e72f948ea7d5de8288fdd3559316b Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/usage_constants.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/usage_lib.cpython-310.pyc b/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/usage_lib.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eab89719d353c6ba275206b3cb9d9ecc64866ced Binary files /dev/null and b/vllm/lib/python3.10/site-packages/ray/_private/usage/__pycache__/usage_lib.cpython-310.pyc differ diff --git a/vllm/lib/python3.10/site-packages/ray/_private/usage/usage_lib.py b/vllm/lib/python3.10/site-packages/ray/_private/usage/usage_lib.py new file mode 100644 index 0000000000000000000000000000000000000000..558f56c602ef0b39e6d084f60ffbfbb026ff9175 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/_private/usage/usage_lib.py @@ -0,0 +1,964 @@ +"""This is the module that is in charge of Ray usage report (telemetry) APIs. + +NOTE: Ray's usage report is currently "on by default". + One could opt-out, see details at https://docs.ray.io/en/master/cluster/usage-stats.html. # noqa + +Ray usage report follows the specification from +https://docs.google.com/document/d/1ZT-l9YbGHh-iWRUC91jS-ssQ5Qe2UQ43Lsoc1edCalc/edit#heading=h.17dss3b9evbj. # noqa + +# Module + +The module consists of 2 parts. + +## Public API +It contains public APIs to obtain usage report information. +APIs will be added before the usage report becomes opt-in by default. + +## Internal APIs for usage processing/report +The telemetry report consists of 5 components. This module is in charge of the top 2 layers. + +Report -> usage_lib +--------------------- +Usage data processing -> usage_lib +--------------------- +Data storage -> Ray API server +--------------------- +Aggregation -> Ray API server (currently a dashboard server) +--------------------- +Usage data collection -> Various components (Ray agent, GCS, etc.) + usage_lib (cluster metadata). + +Usage report is currently "off by default". You can enable the report by setting an environment variable +RAY_USAGE_STATS_ENABLED=1. For example, `RAY_USAGE_STATS_ENABLED=1 ray start --head`. +Or `RAY_USAGE_STATS_ENABLED=1 python [drivers with ray.init()]`. + +"Ray API server (currently a dashboard server)" reports the usage data to https://usage-stats.ray.io/. + +Data is reported every hour by default. + +Note that it is also possible to configure the interval using the environment variable, +`RAY_USAGE_STATS_REPORT_INTERVAL_S`. + +To see collected/reported data, see `usage_stats.json` inside a temp +folder (e.g., /tmp/ray/session_[id]/*). +""" +import json +import logging +import threading +import os +import platform +import sys +import time +from dataclasses import asdict, dataclass +from enum import Enum, auto +from pathlib import Path +from typing import Dict, List, Optional, Set + +import requests +import yaml + +import ray +from ray._raylet import GcsClient +import ray._private.ray_constants as ray_constants +import ray._private.usage.usage_constants as usage_constant +from ray.experimental.internal_kv import ( + _internal_kv_initialized, + _internal_kv_put, +) +from ray.core.generated import usage_pb2, gcs_pb2 + +logger = logging.getLogger(__name__) +TagKey = usage_pb2.TagKey + +################# +# Internal APIs # +################# + + +@dataclass(init=True) +class ClusterConfigToReport: + cloud_provider: Optional[str] = None + min_workers: Optional[int] = None + max_workers: Optional[int] = None + head_node_instance_type: Optional[str] = None + worker_node_instance_types: Optional[List[str]] = None + + +@dataclass(init=True) +class ClusterStatusToReport: + total_num_cpus: Optional[int] = None + total_num_gpus: Optional[int] = None + total_memory_gb: Optional[float] = None + total_object_store_memory_gb: Optional[float] = None + + +@dataclass(init=True) +class UsageStatsToReport: + """Usage stats to report""" + + #: The schema version of the report. + schema_version: str + #: The source of the data (i.e. OSS). + source: str + #: When the data is collected and reported. + collect_timestamp_ms: int + #: The total number of successful reports for the lifetime of the cluster. + total_success: Optional[int] = None + #: The total number of failed reports for the lifetime of the cluster. + total_failed: Optional[int] = None + #: The sequence number of the report. + seq_number: Optional[int] = None + #: The Ray version in use. + ray_version: Optional[str] = None + #: The Python version in use. + python_version: Optional[str] = None + #: A random id of the cluster session. + session_id: Optional[str] = None + #: The git commit hash of Ray (i.e. ray.__commit__). + git_commit: Optional[str] = None + #: The operating system in use. + os: Optional[str] = None + #: When the cluster is started. + session_start_timestamp_ms: Optional[int] = None + #: The cloud provider found in the cluster.yaml file (e.g., aws). + cloud_provider: Optional[str] = None + #: The min_workers found in the cluster.yaml file. + min_workers: Optional[int] = None + #: The max_workers found in the cluster.yaml file. + max_workers: Optional[int] = None + #: The head node instance type found in the cluster.yaml file (e.g., i3.8xlarge). + head_node_instance_type: Optional[str] = None + #: The worker node instance types found in the cluster.yaml file (e.g., i3.8xlarge). + worker_node_instance_types: Optional[List[str]] = None + #: The total num of cpus in the cluster. + total_num_cpus: Optional[int] = None + #: The total num of gpus in the cluster. + total_num_gpus: Optional[int] = None + #: The total size of memory in the cluster. + total_memory_gb: Optional[float] = None + #: The total size of object store memory in the cluster. + total_object_store_memory_gb: Optional[float] = None + #: The Ray libraries that are used (e.g., rllib). + library_usages: Optional[List[str]] = None + #: The extra tags to report when specified by an + # environment variable RAY_USAGE_STATS_EXTRA_TAGS + extra_usage_tags: Optional[Dict[str, str]] = None + #: The number of alive nodes when the report is generated. + total_num_nodes: Optional[int] = None + #: The total number of running jobs excluding internal ones + # when the report is generated. + total_num_running_jobs: Optional[int] = None + #: The libc version in the OS. + libc_version: Optional[str] = None + #: The hardwares that are used (e.g. Intel Xeon). + hardware_usages: Optional[List[str]] = None + + +@dataclass(init=True) +class UsageStatsToWrite: + """Usage stats to write to `USAGE_STATS_FILE` + + We are writing extra metadata such as the status of report + to this file. + """ + + usage_stats: UsageStatsToReport + # Whether or not the last report succeeded. + success: bool + # The error message of the last report if it happens. + error: str + + +class UsageStatsEnabledness(Enum): + ENABLED_EXPLICITLY = auto() + DISABLED_EXPLICITLY = auto() + ENABLED_BY_DEFAULT = auto() + + +_recorded_library_usages = set() +_recorded_library_usages_lock = threading.Lock() +_recorded_extra_usage_tags = dict() +_recorded_extra_usage_tags_lock = threading.Lock() + + +def _add_to_usage_set(set_name: str, value: str): + assert _internal_kv_initialized() + try: + _internal_kv_put( + f"{set_name}{value}".encode(), + b"", + namespace=usage_constant.USAGE_STATS_NAMESPACE.encode(), + ) + except Exception as e: + logger.debug(f"Failed to add {value} to usage set {set_name}, {e}") + + +def _get_usage_set(gcs_client, set_name: str) -> Set[str]: + try: + result = set() + usages = gcs_client.internal_kv_keys( + set_name.encode(), + namespace=usage_constant.USAGE_STATS_NAMESPACE.encode(), + ) + for usage in usages: + usage = usage.decode("utf-8") + result.add(usage[len(set_name) :]) + + return result + except Exception as e: + logger.debug(f"Failed to get usage set {set_name}, {e}") + return set() + + +def _put_library_usage(library_usage: str): + _add_to_usage_set(usage_constant.LIBRARY_USAGE_SET_NAME, library_usage) + + +def _put_hardware_usage(hardware_usage: str): + _add_to_usage_set(usage_constant.HARDWARE_USAGE_SET_NAME, hardware_usage) + + +def record_extra_usage_tag( + key: TagKey, value: str, gcs_client: Optional[GcsClient] = None +): + """Record extra kv usage tag. + + If the key already exists, the value will be overwritten. + + To record an extra tag, first add the key to the TagKey enum and + then call this function. + It will make a synchronous call to the internal kv store if the tag is updated. + + Args: + key: The key of the tag. + value: The value of the tag. + gcs_client: The GCS client to perform KV operation PUT. Defaults to None. + When None, it will try to get the global client from the internal_kv. + """ + key = TagKey.Name(key).lower() + with _recorded_extra_usage_tags_lock: + if _recorded_extra_usage_tags.get(key) == value: + return + _recorded_extra_usage_tags[key] = value + + if not _internal_kv_initialized() and gcs_client is None: + # This happens if the record is before ray.init and + # no GCS client is used for recording explicitly. + return + + _put_extra_usage_tag(key, value, gcs_client) + + +def _put_extra_usage_tag(key: str, value: str, gcs_client: Optional[GcsClient] = None): + try: + key = f"{usage_constant.EXTRA_USAGE_TAG_PREFIX}{key}".encode() + val = value.encode() + namespace = usage_constant.USAGE_STATS_NAMESPACE.encode() + if gcs_client is not None: + # Use the GCS client. + gcs_client.internal_kv_put(key, val, namespace=namespace) + else: + # Use internal kv. + assert _internal_kv_initialized() + _internal_kv_put(key, val, namespace=namespace) + except Exception as e: + logger.debug(f"Failed to put extra usage tag, {e}") + + +def record_hardware_usage(hardware_usage: str): + """Record hardware usage (e.g. which CPU model is used)""" + assert _internal_kv_initialized() + _put_hardware_usage(hardware_usage) + + +def record_library_usage(library_usage: str): + """Record library usage (e.g. which library is used)""" + with _recorded_library_usages_lock: + if library_usage in _recorded_library_usages: + return + _recorded_library_usages.add(library_usage) + + if not _internal_kv_initialized(): + # This happens if the library is imported before ray.init + return + + # Only report lib usage for driver / ray client / workers. Otherwise, + # it can be reported if the library is imported from + # e.g., API server. + if ( + ray._private.worker.global_worker.mode == ray.SCRIPT_MODE + or ray._private.worker.global_worker.mode == ray.WORKER_MODE + or ray.util.client.ray.is_connected() + ): + _put_library_usage(library_usage) + + +def _put_pre_init_library_usages(): + assert _internal_kv_initialized() + # NOTE: When the lib is imported from a worker, ray should + # always be initialized, so there's no need to register the + # pre init hook. + if not ( + ray._private.worker.global_worker.mode == ray.SCRIPT_MODE + or ray.util.client.ray.is_connected() + ): + return + + for library_usage in _recorded_library_usages: + _put_library_usage(library_usage) + + +def _put_pre_init_extra_usage_tags(): + assert _internal_kv_initialized() + for k, v in _recorded_extra_usage_tags.items(): + _put_extra_usage_tag(k, v) + + +def put_pre_init_usage_stats(): + _put_pre_init_library_usages() + _put_pre_init_extra_usage_tags() + + +def reset_global_state(): + global _recorded_library_usages, _recorded_extra_usage_tags + + with _recorded_library_usages_lock: + _recorded_library_usages = set() + with _recorded_extra_usage_tags_lock: + _recorded_extra_usage_tags = dict() + + +ray._private.worker._post_init_hooks.append(put_pre_init_usage_stats) + + +def _usage_stats_report_url(): + # The usage collection server URL. + # The environment variable is testing-purpose only. + return os.getenv("RAY_USAGE_STATS_REPORT_URL", "https://usage-stats.ray.io/") + + +def _usage_stats_report_interval_s(): + return int(os.getenv("RAY_USAGE_STATS_REPORT_INTERVAL_S", 3600)) + + +def _usage_stats_config_path(): + return os.getenv( + "RAY_USAGE_STATS_CONFIG_PATH", os.path.expanduser("~/.ray/config.json") + ) + + +def _usage_stats_enabledness() -> UsageStatsEnabledness: + # Env var has higher priority than config file. + usage_stats_enabled_env_var = os.getenv(usage_constant.USAGE_STATS_ENABLED_ENV_VAR) + if usage_stats_enabled_env_var == "0": + return UsageStatsEnabledness.DISABLED_EXPLICITLY + elif usage_stats_enabled_env_var == "1": + return UsageStatsEnabledness.ENABLED_EXPLICITLY + elif usage_stats_enabled_env_var is not None: + raise ValueError( + f"Valid value for {usage_constant.USAGE_STATS_ENABLED_ENV_VAR} " + f"env var is 0 or 1, but got {usage_stats_enabled_env_var}" + ) + + usage_stats_enabled_config_var = None + try: + with open(_usage_stats_config_path()) as f: + config = json.load(f) + usage_stats_enabled_config_var = config.get("usage_stats") + except FileNotFoundError: + pass + except Exception as e: + logger.debug(f"Failed to load usage stats config {e}") + + if usage_stats_enabled_config_var is False: + return UsageStatsEnabledness.DISABLED_EXPLICITLY + elif usage_stats_enabled_config_var is True: + return UsageStatsEnabledness.ENABLED_EXPLICITLY + elif usage_stats_enabled_config_var is not None: + raise ValueError( + f"Valid value for 'usage_stats' in {_usage_stats_config_path()}" + f" is true or false, but got {usage_stats_enabled_config_var}" + ) + + # Usage stats is enabled by default. + return UsageStatsEnabledness.ENABLED_BY_DEFAULT + + +def is_nightly_wheel() -> bool: + return ray.__commit__ != "{{RAY_COMMIT_SHA}}" and "dev" in ray.__version__ + + +def usage_stats_enabled() -> bool: + return _usage_stats_enabledness() is not UsageStatsEnabledness.DISABLED_EXPLICITLY + + +def usage_stats_prompt_enabled(): + return int(os.getenv("RAY_USAGE_STATS_PROMPT_ENABLED", "1")) == 1 + + +def _generate_cluster_metadata(*, ray_init_cluster: bool): + """Return a dictionary of cluster metadata. + + Params: + ray_init_cluster: Whether the cluster is started by ray.init() + """ + ray_version, python_version = ray._private.utils.compute_version_info() + # These two metadata is necessary although usage report is not enabled + # to check version compatibility. + metadata = { + "ray_version": ray_version, + "python_version": python_version, + "ray_init_cluster": ray_init_cluster, + } + # Additional metadata is recorded only when usage stats are enabled. + if usage_stats_enabled(): + metadata.update( + { + "git_commit": ray.__commit__, + "os": sys.platform, + "session_start_timestamp_ms": int(time.time() * 1000), + } + ) + if sys.platform == "linux": + # Record llibc version + (lib, ver) = platform.libc_ver() + if not lib: + metadata.update({"libc_version": "NA"}) + else: + metadata.update({"libc_version": f"{lib}:{ver}"}) + return metadata + + +def show_usage_stats_prompt(cli: bool) -> None: + if not usage_stats_prompt_enabled(): + return + + from ray.autoscaler._private.cli_logger import cli_logger + + prompt_print = cli_logger.print if cli else print + + usage_stats_enabledness = _usage_stats_enabledness() + if usage_stats_enabledness is UsageStatsEnabledness.DISABLED_EXPLICITLY: + prompt_print(usage_constant.USAGE_STATS_DISABLED_MESSAGE) + elif usage_stats_enabledness is UsageStatsEnabledness.ENABLED_BY_DEFAULT: + if not cli: + prompt_print( + usage_constant.USAGE_STATS_ENABLED_BY_DEFAULT_FOR_RAY_INIT_MESSAGE + ) + elif cli_logger.interactive: + enabled = cli_logger.confirm( + False, + usage_constant.USAGE_STATS_CONFIRMATION_MESSAGE, + _default=True, + _timeout_s=10, + ) + set_usage_stats_enabled_via_env_var(enabled) + # Remember user's choice. + try: + set_usage_stats_enabled_via_config(enabled) + except Exception as e: + logger.debug( + f"Failed to persist usage stats choice for future clusters: {e}" + ) + if enabled: + prompt_print(usage_constant.USAGE_STATS_ENABLED_FOR_CLI_MESSAGE) + else: + prompt_print(usage_constant.USAGE_STATS_DISABLED_MESSAGE) + else: + prompt_print( + usage_constant.USAGE_STATS_ENABLED_BY_DEFAULT_FOR_CLI_MESSAGE, + ) + else: + assert usage_stats_enabledness is UsageStatsEnabledness.ENABLED_EXPLICITLY + prompt_print( + usage_constant.USAGE_STATS_ENABLED_FOR_CLI_MESSAGE + if cli + else usage_constant.USAGE_STATS_ENABLED_FOR_RAY_INIT_MESSAGE + ) + + +def set_usage_stats_enabled_via_config(enabled) -> None: + config = {} + try: + with open(_usage_stats_config_path()) as f: + config = json.load(f) + if not isinstance(config, dict): + logger.debug( + f"Invalid ray config file, should be a json dict but got {type(config)}" + ) + config = {} + except FileNotFoundError: + pass + except Exception as e: + logger.debug(f"Failed to load ray config file {e}") + + config["usage_stats"] = enabled + + try: + os.makedirs(os.path.dirname(_usage_stats_config_path()), exist_ok=True) + with open(_usage_stats_config_path(), "w") as f: + json.dump(config, f) + except Exception as e: + raise Exception( + "Failed to " + f'{"enable" if enabled else "disable"}' + ' usage stats by writing {"usage_stats": ' + f'{"true" if enabled else "false"}' + "} to " + f"{_usage_stats_config_path()}" + ) from e + + +def set_usage_stats_enabled_via_env_var(enabled) -> None: + os.environ[usage_constant.USAGE_STATS_ENABLED_ENV_VAR] = "1" if enabled else "0" + + +def put_cluster_metadata(gcs_client, *, ray_init_cluster) -> None: + """Generate the cluster metadata and store it to GCS. + + It is a blocking API. + + Params: + gcs_client: The GCS client to perform KV operation PUT. + ray_init_cluster: Whether the cluster is started by ray.init() + + Raises: + gRPC exceptions if PUT fails. + """ + metadata = _generate_cluster_metadata(ray_init_cluster=ray_init_cluster) + gcs_client.internal_kv_put( + usage_constant.CLUSTER_METADATA_KEY, + json.dumps(metadata).encode(), + overwrite=True, + namespace=ray_constants.KV_NAMESPACE_CLUSTER, + ) + return metadata + + +def get_total_num_running_jobs_to_report(gcs_client) -> Optional[int]: + """Return the total number of running jobs in the cluster excluding internal ones""" + try: + result = gcs_client.get_all_job_info( + skip_submission_job_info_field=True, skip_is_running_tasks_field=True + ) + total_num_running_jobs = 0 + for job_info in result.values(): + if not job_info.is_dead and not job_info.config.ray_namespace.startswith( + "_ray_internal" + ): + total_num_running_jobs += 1 + return total_num_running_jobs + except Exception as e: + logger.info(f"Faile to query number of running jobs in the cluster: {e}") + return None + + +def get_total_num_nodes_to_report(gcs_client, timeout=None) -> Optional[int]: + """Return the total number of alive nodes in the cluster""" + try: + result = gcs_client.get_all_node_info(timeout=timeout) + total_num_nodes = 0 + for node_id, node_info in result.items(): + if node_info.state == gcs_pb2.GcsNodeInfo.GcsNodeState.ALIVE: + total_num_nodes += 1 + return total_num_nodes + except Exception as e: + logger.info(f"Faile to query number of nodes in the cluster: {e}") + return None + + +def get_library_usages_to_report(gcs_client) -> List[str]: + return list(_get_usage_set(gcs_client, usage_constant.LIBRARY_USAGE_SET_NAME)) + + +def get_hardware_usages_to_report(gcs_client) -> List[str]: + return list(_get_usage_set(gcs_client, usage_constant.HARDWARE_USAGE_SET_NAME)) + + +def get_extra_usage_tags_to_report(gcs_client) -> Dict[str, str]: + """Get the extra usage tags from env var and gcs kv store. + + The env var should be given this way; key=value;key=value. + If parsing is failed, it will return the empty data. + + Returns: + Extra usage tags as kv pairs. + """ + extra_usage_tags = dict() + + extra_usage_tags_env_var = os.getenv("RAY_USAGE_STATS_EXTRA_TAGS", None) + if extra_usage_tags_env_var: + try: + kvs = extra_usage_tags_env_var.strip(";").split(";") + for kv in kvs: + k, v = kv.split("=") + extra_usage_tags[k] = v + except Exception as e: + logger.info(f"Failed to parse extra usage tags env var. Error: {e}") + + valid_tag_keys = [tag_key.lower() for tag_key in TagKey.keys()] + try: + keys = gcs_client.internal_kv_keys( + usage_constant.EXTRA_USAGE_TAG_PREFIX.encode(), + namespace=usage_constant.USAGE_STATS_NAMESPACE.encode(), + ) + for key in keys: + value = gcs_client.internal_kv_get( + key, namespace=usage_constant.USAGE_STATS_NAMESPACE.encode() + ) + key = key.decode("utf-8") + key = key[len(usage_constant.EXTRA_USAGE_TAG_PREFIX) :] + assert key in valid_tag_keys + extra_usage_tags[key] = value.decode("utf-8") + except Exception as e: + logger.info(f"Failed to get extra usage tags from kv store {e}") + return extra_usage_tags + + +def _get_cluster_status_to_report_v2(gcs_client) -> ClusterStatusToReport: + """ + Get the current status of this cluster. A temporary proxy for the + autoscaler v2 API. + + It is a blocking API. + + Params: + gcs_client: The GCS client. + + Returns: + The current cluster status or empty ClusterStatusToReport + if it fails to get that information. + """ + from ray.autoscaler.v2.sdk import get_cluster_status + + result = ClusterStatusToReport() + try: + cluster_status = get_cluster_status(gcs_client.address) + total_resources = cluster_status.total_resources() + result.total_num_cpus = int(total_resources.get("CPU", 0)) + result.total_num_gpus = int(total_resources.get("GPU", 0)) + + to_GiB = 1 / 2**30 + result.total_memory_gb = total_resources.get("memory", 0) * to_GiB + result.total_object_store_memory_gb = ( + total_resources.get("object_store_memory", 0) * to_GiB + ) + except Exception as e: + logger.info(f"Failed to get cluster status to report {e}") + finally: + return result + + +def get_cluster_status_to_report(gcs_client) -> ClusterStatusToReport: + """Get the current status of this cluster. + + It is a blocking API. + + Params: + gcs_client: The GCS client to perform KV operation GET. + + Returns: + The current cluster status or empty if it fails to get that information. + """ + try: + + from ray.autoscaler.v2.utils import is_autoscaler_v2 + + if is_autoscaler_v2(): + return _get_cluster_status_to_report_v2(gcs_client) + + cluster_status = gcs_client.internal_kv_get( + ray._private.ray_constants.DEBUG_AUTOSCALING_STATUS.encode(), + namespace=None, + ) + if not cluster_status: + return ClusterStatusToReport() + + result = ClusterStatusToReport() + to_GiB = 1 / 2**30 + cluster_status = json.loads(cluster_status.decode("utf-8")) + if ( + "load_metrics_report" not in cluster_status + or "usage" not in cluster_status["load_metrics_report"] + ): + return ClusterStatusToReport() + + usage = cluster_status["load_metrics_report"]["usage"] + # usage is a map from resource to (used, total) pair + if "CPU" in usage: + result.total_num_cpus = int(usage["CPU"][1]) + if "GPU" in usage: + result.total_num_gpus = int(usage["GPU"][1]) + if "memory" in usage: + result.total_memory_gb = usage["memory"][1] * to_GiB + if "object_store_memory" in usage: + result.total_object_store_memory_gb = ( + usage["object_store_memory"][1] * to_GiB + ) + return result + except Exception as e: + logger.info(f"Failed to get cluster status to report {e}") + return ClusterStatusToReport() + + +def get_cluster_config_to_report( + cluster_config_file_path: str, +) -> ClusterConfigToReport: + """Get the static cluster (autoscaler) config used to launch this cluster. + + Params: + cluster_config_file_path: The file path to the cluster config file. + + Returns: + The cluster (autoscaler) config or empty if it fails to get that information. + """ + + def get_instance_type(node_config): + if not node_config: + return None + if "InstanceType" in node_config: + # aws + return node_config["InstanceType"] + if "machineType" in node_config: + # gcp + return node_config["machineType"] + if ( + "azure_arm_parameters" in node_config + and "vmSize" in node_config["azure_arm_parameters"] + ): + return node_config["azure_arm_parameters"]["vmSize"] + return None + + try: + with open(cluster_config_file_path) as f: + config = yaml.safe_load(f) + result = ClusterConfigToReport() + if "min_workers" in config: + result.min_workers = config["min_workers"] + if "max_workers" in config: + result.max_workers = config["max_workers"] + + if "provider" in config and "type" in config["provider"]: + result.cloud_provider = config["provider"]["type"] + + if "head_node_type" not in config: + return result + if "available_node_types" not in config: + return result + head_node_type = config["head_node_type"] + available_node_types = config["available_node_types"] + for available_node_type in available_node_types: + if available_node_type == head_node_type: + head_node_instance_type = get_instance_type( + available_node_types[available_node_type].get("node_config") + ) + if head_node_instance_type: + result.head_node_instance_type = head_node_instance_type + else: + worker_node_instance_type = get_instance_type( + available_node_types[available_node_type].get("node_config") + ) + if worker_node_instance_type: + result.worker_node_instance_types = ( + result.worker_node_instance_types or set() + ) + result.worker_node_instance_types.add(worker_node_instance_type) + if result.worker_node_instance_types: + result.worker_node_instance_types = list( + result.worker_node_instance_types + ) + return result + except FileNotFoundError: + # It's a manually started cluster or k8s cluster + result = ClusterConfigToReport() + # Check if we're on Kubernetes + if usage_constant.KUBERNETES_SERVICE_HOST_ENV in os.environ: + # Check if we're using KubeRay >= 0.4.0. + if usage_constant.KUBERAY_ENV in os.environ: + result.cloud_provider = usage_constant.PROVIDER_KUBERAY + # Else, we're on Kubernetes but not in either of the above categories. + else: + result.cloud_provider = usage_constant.PROVIDER_KUBERNETES_GENERIC + return result + except Exception as e: + logger.info(f"Failed to get cluster config to report {e}") + return ClusterConfigToReport() + + +def get_cluster_metadata(gcs_client) -> dict: + """Get the cluster metadata from GCS. + + It is a blocking API. + + This will return None if `put_cluster_metadata` was never called. + + Params: + gcs_client: The GCS client to perform KV operation GET. + + Returns: + The cluster metadata in a dictinoary. + + Raises: + RuntimeError if it fails to obtain cluster metadata from GCS. + """ + return json.loads( + gcs_client.internal_kv_get( + usage_constant.CLUSTER_METADATA_KEY, + namespace=ray_constants.KV_NAMESPACE_CLUSTER, + ).decode("utf-8") + ) + + +def is_ray_init_cluster(gcs_client: ray._raylet.GcsClient) -> bool: + """Return whether the cluster is started by ray.init()""" + cluster_metadata = get_cluster_metadata(gcs_client) + return cluster_metadata["ray_init_cluster"] + + +def generate_disabled_report_data() -> UsageStatsToReport: + """Generate the report data indicating usage stats is disabled""" + data = UsageStatsToReport( + schema_version=usage_constant.SCHEMA_VERSION, + source=os.getenv( + usage_constant.USAGE_STATS_SOURCE_ENV_VAR, + usage_constant.USAGE_STATS_SOURCE_OSS, + ), + collect_timestamp_ms=int(time.time() * 1000), + ) + return data + + +def generate_report_data( + cluster_config_to_report: ClusterConfigToReport, + total_success: int, + total_failed: int, + seq_number: int, + gcs_address: str, + cluster_id: str, +) -> UsageStatsToReport: + """Generate the report data. + + Params: + cluster_config_to_report: The cluster (autoscaler) + config generated by `get_cluster_config_to_report`. + total_success: The total number of successful report + for the lifetime of the cluster. + total_failed: The total number of failed report + for the lifetime of the cluster. + seq_number: The sequence number that's incremented whenever + a new report is sent. + gcs_address: the address of gcs to get data to report. + cluster_id: hex id of the cluster. + + Returns: + UsageStats + """ + assert cluster_id + + gcs_client = ray._raylet.GcsClient( + address=gcs_address, nums_reconnect_retry=20, cluster_id=cluster_id + ) + + cluster_metadata = get_cluster_metadata(gcs_client) + cluster_status_to_report = get_cluster_status_to_report(gcs_client) + + data = UsageStatsToReport( + schema_version=usage_constant.SCHEMA_VERSION, + source=os.getenv( + usage_constant.USAGE_STATS_SOURCE_ENV_VAR, + usage_constant.USAGE_STATS_SOURCE_OSS, + ), + collect_timestamp_ms=int(time.time() * 1000), + total_success=total_success, + total_failed=total_failed, + seq_number=seq_number, + ray_version=cluster_metadata["ray_version"], + python_version=cluster_metadata["python_version"], + session_id=cluster_id, + git_commit=cluster_metadata["git_commit"], + os=cluster_metadata["os"], + session_start_timestamp_ms=cluster_metadata["session_start_timestamp_ms"], + cloud_provider=cluster_config_to_report.cloud_provider, + min_workers=cluster_config_to_report.min_workers, + max_workers=cluster_config_to_report.max_workers, + head_node_instance_type=cluster_config_to_report.head_node_instance_type, + worker_node_instance_types=cluster_config_to_report.worker_node_instance_types, + total_num_cpus=cluster_status_to_report.total_num_cpus, + total_num_gpus=cluster_status_to_report.total_num_gpus, + total_memory_gb=cluster_status_to_report.total_memory_gb, + total_object_store_memory_gb=cluster_status_to_report.total_object_store_memory_gb, # noqa: E501 + library_usages=get_library_usages_to_report(gcs_client), + extra_usage_tags=get_extra_usage_tags_to_report(gcs_client), + total_num_nodes=get_total_num_nodes_to_report(gcs_client), + total_num_running_jobs=get_total_num_running_jobs_to_report(gcs_client), + libc_version=cluster_metadata.get("libc_version"), + hardware_usages=get_hardware_usages_to_report(gcs_client), + ) + return data + + +def generate_write_data( + usage_stats: UsageStatsToReport, + error: str, +) -> UsageStatsToWrite: + """Generate the report data. + + Params: + usage_stats: The usage stats that were reported. + error: The error message of failed reports. + + Returns: + UsageStatsToWrite + """ + data = UsageStatsToWrite( + usage_stats=usage_stats, + success=error is None, + error=error, + ) + return data + + +class UsageReportClient: + """The client implementation for usage report. + + It is in charge of writing usage stats to the directory + and report usage stats. + """ + + def write_usage_data(self, data: UsageStatsToWrite, dir_path: str) -> None: + """Write the usage data to the directory. + + Params: + data: Data to report + dir_path: The path to the directory to write usage data. + """ + # Atomically update the file. + dir_path = Path(dir_path) + destination = dir_path / usage_constant.USAGE_STATS_FILE + temp = dir_path / f"{usage_constant.USAGE_STATS_FILE}.tmp" + with temp.open(mode="w") as json_file: + json_file.write(json.dumps(asdict(data))) + if sys.platform == "win32": + # Windows 32 doesn't support atomic renaming, so we should delete + # the file first. + destination.unlink(missing_ok=True) + temp.rename(destination) + + def report_usage_data(self, url: str, data: UsageStatsToReport) -> None: + """Report the usage data to the usage server. + + Params: + url: The URL to update resource usage. + data: Data to report. + + Raises: + requests.HTTPError if requests fails. + """ + r = requests.request( + "POST", + url, + headers={"Content-Type": "application/json"}, + json=asdict(data), + timeout=10, + ) + r.raise_for_status() + return r diff --git a/vllm/lib/python3.10/site-packages/ray/widgets/templates/context.html.j2 b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context.html.j2 new file mode 100644 index 0000000000000000000000000000000000000000..26cc0ef6c8784c9859151f8553b240d7a94e9360 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context.html.j2 @@ -0,0 +1,6 @@ + diff --git a/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_dashrow.html.j2 b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_dashrow.html.j2 new file mode 100644 index 0000000000000000000000000000000000000000..47fbc2fa6f6da7e8a44c88c0e07ae51c6a737dbd --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_dashrow.html.j2 @@ -0,0 +1,4 @@ + + Dashboard: + {{ dashboard_url }} + diff --git a/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_logo.html.j2 b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_logo.html.j2 new file mode 100644 index 0000000000000000000000000000000000000000..9233fe3a77226c760442d5366b8d5fb65b93abcd --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_logo.html.j2 @@ -0,0 +1,13 @@ + diff --git a/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_table.html.j2 b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_table.html.j2 new file mode 100644 index 0000000000000000000000000000000000000000..d06822d0c1f56534e5009ea2ff81340fdc6f7850 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/widgets/templates/context_table.html.j2 @@ -0,0 +1,11 @@ + + + + + + + + + + {{ dashboard_row }} + diff --git a/vllm/lib/python3.10/site-packages/ray/widgets/templates/scrollableTable.html.j2 b/vllm/lib/python3.10/site-packages/ray/widgets/templates/scrollableTable.html.j2 new file mode 100644 index 0000000000000000000000000000000000000000..2ec1637b92ee7de3d22bba0a956b8539464c0501 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/widgets/templates/scrollableTable.html.j2 @@ -0,0 +1,20 @@ + + diff --git a/vllm/lib/python3.10/site-packages/ray/widgets/templates/title_data_mini.html.j2 b/vllm/lib/python3.10/site-packages/ray/widgets/templates/title_data_mini.html.j2 new file mode 100644 index 0000000000000000000000000000000000000000..bfe654c56346b09a1999dda379d129aaf1e317be --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/widgets/templates/title_data_mini.html.j2 @@ -0,0 +1,4 @@ + diff --git a/vllm/lib/python3.10/site-packages/ray/widgets/templates/tune_status_messages.html.j2 b/vllm/lib/python3.10/site-packages/ray/widgets/templates/tune_status_messages.html.j2 new file mode 100644 index 0000000000000000000000000000000000000000..da8e75f5f58d3a5c78274429e7490947aff4c410 --- /dev/null +++ b/vllm/lib/python3.10/site-packages/ray/widgets/templates/tune_status_messages.html.j2 @@ -0,0 +1,25 @@ +
+
+

Messages

+ {{ memory_message }} + {{ trial_progress_messages }} + {{ trial_errors }} +
+