ZTWHHH commited on
Commit
b2fd3be
·
verified ·
1 Parent(s): 4d4e9e0

Add files using upload-large-folder tool

Browse files
This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. videollama2/lib/python3.10/site-packages/torch/include/ATen/ATen.h +37 -0
  2. videollama2/lib/python3.10/site-packages/torch/include/ATen/AccumulateType.h +147 -0
  3. videollama2/lib/python3.10/site-packages/torch/include/ATen/ArrayRef.h +2 -0
  4. videollama2/lib/python3.10/site-packages/torch/include/ATen/Backend.h +2 -0
  5. videollama2/lib/python3.10/site-packages/torch/include/ATen/Backtrace.h +2 -0
  6. videollama2/lib/python3.10/site-packages/torch/include/ATen/CPUFixedAllocator.h +33 -0
  7. videollama2/lib/python3.10/site-packages/torch/include/ATen/CPUFunctions_inl.h +569 -0
  8. videollama2/lib/python3.10/site-packages/torch/include/ATen/CUDAFunctions.h +29 -0
  9. videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradFunctions.h +29 -0
  10. videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradFunctions_inl.h +500 -0
  11. videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradNestedTensorFunctions.h +29 -0
  12. videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradNestedTensorFunctions_inl.h +25 -0
  13. videollama2/lib/python3.10/site-packages/torch/include/ATen/Config.h +22 -0
  14. videollama2/lib/python3.10/site-packages/torch/include/ATen/Context.h +518 -0
  15. videollama2/lib/python3.10/site-packages/torch/include/ATen/DimVector.h +2 -0
  16. videollama2/lib/python3.10/site-packages/torch/include/ATen/Dimname.h +1 -0
  17. videollama2/lib/python3.10/site-packages/torch/include/ATen/DynamicLibrary.h +34 -0
  18. videollama2/lib/python3.10/site-packages/torch/include/ATen/EmptyTensor.h +160 -0
  19. videollama2/lib/python3.10/site-packages/torch/include/ATen/Formatting.h +1 -0
  20. videollama2/lib/python3.10/site-packages/torch/include/ATen/FuncTorchTLS.h +46 -0
  21. videollama2/lib/python3.10/site-packages/torch/include/ATen/FunctionalStorageImpl.h +124 -0
  22. videollama2/lib/python3.10/site-packages/torch/include/ATen/FunctionalTensorWrapper.h +392 -0
  23. videollama2/lib/python3.10/site-packages/torch/include/ATen/Functions.h +1405 -0
  24. videollama2/lib/python3.10/site-packages/torch/include/ATen/InferSize.h +87 -0
  25. videollama2/lib/python3.10/site-packages/torch/include/ATen/InitialTensorOptions.h +15 -0
  26. videollama2/lib/python3.10/site-packages/torch/include/ATen/LegacyVmapMode.h +26 -0
  27. videollama2/lib/python3.10/site-packages/torch/include/ATen/LinalgBackend.h +31 -0
  28. videollama2/lib/python3.10/site-packages/torch/include/ATen/MapAllocator.h +139 -0
  29. videollama2/lib/python3.10/site-packages/torch/include/ATen/MatrixRef.h +109 -0
  30. videollama2/lib/python3.10/site-packages/torch/include/ATen/MetaFunctions.h +29 -0
  31. videollama2/lib/python3.10/site-packages/torch/include/ATen/MethodOperators.h +441 -0
  32. videollama2/lib/python3.10/site-packages/torch/include/ATen/NamedTensor.h +1 -0
  33. videollama2/lib/python3.10/site-packages/torch/include/ATen/NativeFunctions.h +1295 -0
  34. videollama2/lib/python3.10/site-packages/torch/include/ATen/OpMathType.h +59 -0
  35. videollama2/lib/python3.10/site-packages/torch/include/ATen/PTThreadPool.h +17 -0
  36. videollama2/lib/python3.10/site-packages/torch/include/ATen/ParallelFuture.h +13 -0
  37. videollama2/lib/python3.10/site-packages/torch/include/ATen/ParallelNative.h +19 -0
  38. videollama2/lib/python3.10/site-packages/torch/include/ATen/ParallelOpenMP.h +58 -0
  39. videollama2/lib/python3.10/site-packages/torch/include/ATen/PythonTorchFunctionTLS.h +34 -0
  40. videollama2/lib/python3.10/site-packages/torch/include/ATen/RedispatchFunctions.h +0 -0
  41. videollama2/lib/python3.10/site-packages/torch/include/ATen/SavedTensorHooks.h +52 -0
  42. videollama2/lib/python3.10/site-packages/torch/include/ATen/ScalarOps.h +71 -0
  43. videollama2/lib/python3.10/site-packages/torch/include/ATen/SmallVector.h +2 -0
  44. videollama2/lib/python3.10/site-packages/torch/include/ATen/SparseCsrTensorImpl.h +182 -0
  45. videollama2/lib/python3.10/site-packages/torch/include/ATen/SparseCsrTensorUtils.h +415 -0
  46. videollama2/lib/python3.10/site-packages/torch/include/ATen/Storage.h +2 -0
  47. videollama2/lib/python3.10/site-packages/torch/include/ATen/StorageUtils.h +49 -0
  48. videollama2/lib/python3.10/site-packages/torch/include/ATen/TensorAccessor.h +2 -0
  49. videollama2/lib/python3.10/site-packages/torch/include/ATen/TensorIteratorInternal.h +72 -0
  50. videollama2/lib/python3.10/site-packages/torch/include/ATen/TensorOperators.h +54 -0
videollama2/lib/python3.10/site-packages/torch/include/ATen/ATen.h ADDED
@@ -0,0 +1,37 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #if !defined(_MSC_VER) && __cplusplus < 201703L
4
+ #error C++17 or later compatible compiler is required to use ATen.
5
+ #endif
6
+
7
+ #include <ATen/Context.h>
8
+ #include <ATen/Device.h>
9
+ #include <ATen/DeviceGuard.h>
10
+ #include <ATen/DimVector.h>
11
+ #include <ATen/Dispatch.h>
12
+ #include <ATen/Formatting.h>
13
+ #include <ATen/Functions.h>
14
+ #include <ATen/NamedTensor.h>
15
+ #include <ATen/ScalarOps.h>
16
+ #include <ATen/Tensor.h>
17
+ #include <ATen/TensorGeometry.h>
18
+ #include <ATen/TensorIndexing.h>
19
+ #include <ATen/TensorOperators.h>
20
+ #include <ATen/Version.h>
21
+ #include <ATen/core/ATenGeneral.h>
22
+ #include <ATen/core/Generator.h>
23
+ #include <ATen/core/Reduction.h>
24
+ #include <ATen/core/Scalar.h>
25
+ #include <ATen/core/UnsafeFromTH.h>
26
+ #include <ATen/core/ivalue.h>
27
+ #include <ATen/core/jit_type.h>
28
+ #include <c10/core/Allocator.h>
29
+ #include <c10/core/InferenceMode.h>
30
+ #include <c10/core/Layout.h>
31
+ #include <c10/core/Storage.h>
32
+ #include <c10/core/TensorOptions.h>
33
+ #include <c10/util/Exception.h>
34
+
35
+ // TODO: try to remove this
36
+ // There is some back story, see https://github.com/pytorch/pytorch/issues/48684
37
+ #include <ATen/NativeFunctions.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/AccumulateType.h ADDED
@@ -0,0 +1,147 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ #include <ATen/Config.h>
3
+ #include <c10/core/DeviceType.h>
4
+ #include <c10/core/ScalarType.h>
5
+ #include <c10/util/BFloat16.h>
6
+ #include <c10/util/Float8_e4m3fn.h>
7
+ #include <c10/util/Float8_e5m2.h>
8
+ #include <c10/util/Half.h>
9
+
10
+ // Defines the accumulation type for a scalar type.
11
+ // Example:
12
+ // using accscalar_t = acc_type<scalar_t, /*is_cuda*/true>;
13
+ //
14
+ // Accumulation types are an important concept in numeric computing
15
+ // because you frequently want to perform intermediate computations
16
+ // at a higher precision than the input and output precision, to avoid
17
+ // compounding internal rounding errors. Accumulation is the most
18
+ // well-known intermediate computation (it is of great importance for
19
+ // sum reduction and matrix multiply, for example), but in PyTorch
20
+ // acc_type ends up getting used for all sorts of other intermediate
21
+ // computations, so it perhaps would be more accurately (ahem) called an
22
+ // "accurate" type. acc_type is especially important for reduced
23
+ // precision operations like float16 and bfloat16, where relatively
24
+ // benign looking inputs can easily end up overflowing/underflowing.
25
+ //
26
+ // acc_type is parametrized by whether or not you are running on CUDA
27
+ // or not, because on CUDA double precision operations are expensive
28
+ // and so by default, we don't actually want to use double as an
29
+ // acc_type on CUDA. A lot of things are typed out below, but
30
+ // basically, the table is generated by a few rules:
31
+ //
32
+ // If bool:
33
+ // Use 'bool' as acc_type.
34
+ // If floating point:
35
+ // If CUDA, use 'float' as acc_type (unless scalar_t is double),
36
+ // otherwise (CPU) use 'double'
37
+ // If integral:
38
+ // Use 'int64_t' as acc_type
39
+ //
40
+ // You're not forced to use this template; if you happen to know
41
+ // something specific about your use case, you can specify your own
42
+ // desired behavior. This template, however, will give you a reasonable
43
+ // default that will work for all dtypes supported in PyTorch.
44
+
45
+ #if defined(__CUDACC__)
46
+ #include <cuda.h>
47
+ #include <cuda_fp16.h>
48
+ #elif defined(__HIPCC__)
49
+ #include <hip/hip_fp16.h>
50
+ #include <hip/hip_runtime.h>
51
+ #endif
52
+
53
+ namespace at {
54
+
55
+ template <typename T, c10::DeviceType D>
56
+ struct AccumulateTypeDevice {};
57
+
58
+ template <typename T, bool>
59
+ struct AccumulateType {};
60
+
61
+ template <typename T>
62
+ struct AccumulateType<T, false> {
63
+ using type = typename AccumulateTypeDevice<T, c10::DeviceType::CPU>::type;
64
+ };
65
+
66
+ template <typename T>
67
+ struct AccumulateType<T, true> {
68
+ using type = typename AccumulateTypeDevice<T, c10::DeviceType::CUDA>::type;
69
+ };
70
+
71
+ template <typename T, c10::DeviceType device>
72
+ using acc_type_device = typename AccumulateTypeDevice<T, device>::type;
73
+
74
+ template <typename T, bool is_cuda>
75
+ using acc_type = typename AccumulateType<T, is_cuda>::type;
76
+
77
+ #define ACC_TYPE(t, acc_t, device_type) \
78
+ template <> \
79
+ struct AccumulateTypeDevice<t, device_type> { \
80
+ using type = acc_t; \
81
+ };
82
+ #define MPS_ACC_TYPE(t, acc_t) ACC_TYPE(t, acc_t, c10::DeviceType::MPS)
83
+ #define CUDA_ACC_TYPE(t, acc_t) ACC_TYPE(t, acc_t, c10::DeviceType::CUDA)
84
+ #define CPU_ACC_TYPE(t, acc_t) ACC_TYPE(t, acc_t, c10::DeviceType::CPU)
85
+
86
+ MPS_ACC_TYPE(BFloat16, float);
87
+ MPS_ACC_TYPE(Half, float);
88
+ MPS_ACC_TYPE(Float8_e5m2, float);
89
+ MPS_ACC_TYPE(Float8_e4m3fn, float);
90
+ MPS_ACC_TYPE(float, float);
91
+ MPS_ACC_TYPE(double, float);
92
+ MPS_ACC_TYPE(int8_t, int64_t);
93
+ MPS_ACC_TYPE(uint8_t, int64_t);
94
+ MPS_ACC_TYPE(char, int64_t);
95
+ MPS_ACC_TYPE(int16_t, int64_t);
96
+ MPS_ACC_TYPE(int32_t, int64_t);
97
+ MPS_ACC_TYPE(int64_t, int64_t);
98
+ MPS_ACC_TYPE(bool, bool);
99
+ MPS_ACC_TYPE(c10::complex<Half>, c10::complex<float>);
100
+ MPS_ACC_TYPE(c10::complex<float>, c10::complex<float>);
101
+ MPS_ACC_TYPE(c10::complex<double>, c10::complex<float>);
102
+
103
+ #if defined(__CUDACC__) || defined(__HIPCC__)
104
+ CUDA_ACC_TYPE(half, float);
105
+ #endif
106
+ CUDA_ACC_TYPE(BFloat16, float);
107
+ CUDA_ACC_TYPE(Half, float);
108
+ CUDA_ACC_TYPE(Float8_e5m2, float);
109
+ CUDA_ACC_TYPE(Float8_e4m3fn, float);
110
+ CUDA_ACC_TYPE(float, float);
111
+ CUDA_ACC_TYPE(double, double);
112
+ CUDA_ACC_TYPE(int8_t, int64_t);
113
+ CUDA_ACC_TYPE(uint8_t, int64_t);
114
+ CUDA_ACC_TYPE(char, int64_t);
115
+ CUDA_ACC_TYPE(int16_t, int64_t);
116
+ CUDA_ACC_TYPE(int32_t, int64_t);
117
+ CUDA_ACC_TYPE(int64_t, int64_t);
118
+ CUDA_ACC_TYPE(bool, bool);
119
+ CUDA_ACC_TYPE(c10::complex<Half>, c10::complex<float>);
120
+ CUDA_ACC_TYPE(c10::complex<float>, c10::complex<float>);
121
+ CUDA_ACC_TYPE(c10::complex<double>, c10::complex<double>);
122
+
123
+ CPU_ACC_TYPE(BFloat16, float);
124
+ CPU_ACC_TYPE(Half, float);
125
+ CPU_ACC_TYPE(Float8_e5m2, float);
126
+ CPU_ACC_TYPE(Float8_e5m2fnuz, float);
127
+ CPU_ACC_TYPE(Float8_e4m3fn, float);
128
+ CPU_ACC_TYPE(Float8_e4m3fnuz, float);
129
+ CPU_ACC_TYPE(float, double);
130
+ CPU_ACC_TYPE(double, double);
131
+ CPU_ACC_TYPE(int8_t, int64_t);
132
+ CPU_ACC_TYPE(uint8_t, int64_t);
133
+ CPU_ACC_TYPE(char, int64_t);
134
+ CPU_ACC_TYPE(int16_t, int64_t);
135
+ CPU_ACC_TYPE(int32_t, int64_t);
136
+ CPU_ACC_TYPE(int64_t, int64_t);
137
+ CPU_ACC_TYPE(bool, bool);
138
+ CPU_ACC_TYPE(c10::complex<Half>, c10::complex<float>);
139
+ CPU_ACC_TYPE(c10::complex<float>, c10::complex<double>);
140
+ CPU_ACC_TYPE(c10::complex<double>, c10::complex<double>);
141
+
142
+ TORCH_API c10::ScalarType toAccumulateType(
143
+ c10::ScalarType type,
144
+ c10::DeviceType device);
145
+ TORCH_API c10::ScalarType toAccumulateType(c10::ScalarType type, bool is_cuda);
146
+
147
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/ArrayRef.h ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ #pragma once
2
+ #include <c10/util/ArrayRef.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/Backend.h ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ #pragma once
2
+ #include <c10/core/Backend.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/Backtrace.h ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ #pragma once
2
+ #include <ATen/core/Backtrace.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/CPUFixedAllocator.h ADDED
@@ -0,0 +1,33 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/core/Allocator.h>
4
+ #include <c10/util/Exception.h>
5
+
6
+ // This file creates a fake allocator that just throws exceptions if
7
+ // it is actually used.
8
+
9
+ // state passed to the allocator is the std::function<void(void*)> called
10
+ // when the blob is release by ATen
11
+
12
+ namespace at {
13
+
14
+ static cpu_fixed_malloc(void*, ptrdiff_t) {
15
+ AT_ERROR("attempting to resize a tensor view of an external blob");
16
+ }
17
+
18
+ static cpu_fixed_realloc(void*, void*, ptrdiff_t) {
19
+ AT_ERROR("attempting to resize a tensor view of an external blob");
20
+ }
21
+
22
+ static cpu_fixed_free(void* state, void* allocation) {
23
+ auto on_release = static_cast<std::function<void(void*)>*>(state);
24
+ (*on_release)(allocation);
25
+ delete on_release;
26
+ }
27
+
28
+ static Allocator CPU_fixed_allocator = {
29
+ cpu_fixed_malloc,
30
+ cpu_fixed_realloc,
31
+ cpu_fixed_free};
32
+
33
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/CPUFunctions_inl.h ADDED
@@ -0,0 +1,569 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunctions_inl.h
3
+
4
+ // NB: The implementing C++ file is RegisterDispatchKey.cpp
5
+
6
+ // The only #includes we need are for custom classes that have defaults in the C++ API
7
+ #include <c10/core/MemoryFormat.h>
8
+ #include <c10/core/Scalar.h>
9
+ #include <ATen/core/Reduction.h>
10
+
11
+ #if defined(AT_PER_OPERATOR_HEADERS) && defined(TORCH_ASSERT_ONLY_METHOD_OPERATORS)
12
+ #error This change adds a dependency on all pytorch operators, meaning the \
13
+ file will need to be re-compiled every time an operator is changed or added. \
14
+ Consider including a specific operator from \
15
+ <ATen/ops/{my_operator}_cpu_dispatch.h>. \
16
+ See NOTE [TORCH_ASSERT_ONLY_METHOD_OPERATORS].
17
+ #endif
18
+
19
+ #include <ATen/ops/_adaptive_avg_pool2d_cpu_dispatch.h>
20
+ #include <ATen/ops/_adaptive_avg_pool2d_backward_cpu_dispatch.h>
21
+ #include <ATen/ops/_adaptive_avg_pool3d_cpu_dispatch.h>
22
+ #include <ATen/ops/_adaptive_avg_pool3d_backward_cpu_dispatch.h>
23
+ #include <ATen/ops/_add_relu_cpu_dispatch.h>
24
+ #include <ATen/ops/_addmm_activation_cpu_dispatch.h>
25
+ #include <ATen/ops/_aminmax_cpu_dispatch.h>
26
+ #include <ATen/ops/_assert_async_cpu_dispatch.h>
27
+ #include <ATen/ops/_cdist_backward_cpu_dispatch.h>
28
+ #include <ATen/ops/_cdist_forward_cpu_dispatch.h>
29
+ #include <ATen/ops/_cholesky_solve_helper_cpu_dispatch.h>
30
+ #include <ATen/ops/_compute_linear_combination_cpu_dispatch.h>
31
+ #include <ATen/ops/_convert_indices_from_coo_to_csr_cpu_dispatch.h>
32
+ #include <ATen/ops/_convert_indices_from_csr_to_coo_cpu_dispatch.h>
33
+ #include <ATen/ops/_ctc_loss_cpu_dispatch.h>
34
+ #include <ATen/ops/_ctc_loss_backward_cpu_dispatch.h>
35
+ #include <ATen/ops/_cummax_helper_cpu_dispatch.h>
36
+ #include <ATen/ops/_cummin_helper_cpu_dispatch.h>
37
+ #include <ATen/ops/_dirichlet_grad_cpu_dispatch.h>
38
+ #include <ATen/ops/_efficientzerotensor_cpu_dispatch.h>
39
+ #include <ATen/ops/_embedding_bag_cpu_dispatch.h>
40
+ #include <ATen/ops/_embedding_bag_dense_backward_cpu_dispatch.h>
41
+ #include <ATen/ops/_embedding_bag_forward_only_cpu_dispatch.h>
42
+ #include <ATen/ops/_embedding_bag_per_sample_weights_backward_cpu_dispatch.h>
43
+ #include <ATen/ops/_empty_affine_quantized_cpu_dispatch.h>
44
+ #include <ATen/ops/_empty_per_channel_affine_quantized_cpu_dispatch.h>
45
+ #include <ATen/ops/_fake_quantize_learnable_per_channel_affine_cpu_dispatch.h>
46
+ #include <ATen/ops/_fake_quantize_learnable_per_channel_affine_backward_cpu_dispatch.h>
47
+ #include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_cpu_dispatch.h>
48
+ #include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward_cpu_dispatch.h>
49
+ #include <ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_cpu_dispatch.h>
50
+ #include <ATen/ops/_fft_c2c_cpu_dispatch.h>
51
+ #include <ATen/ops/_fft_c2r_cpu_dispatch.h>
52
+ #include <ATen/ops/_fft_r2c_cpu_dispatch.h>
53
+ #include <ATen/ops/_foobar_cpu_dispatch.h>
54
+ #include <ATen/ops/_foreach_abs_cpu_dispatch.h>
55
+ #include <ATen/ops/_foreach_acos_cpu_dispatch.h>
56
+ #include <ATen/ops/_foreach_add_cpu_dispatch.h>
57
+ #include <ATen/ops/_foreach_addcdiv_cpu_dispatch.h>
58
+ #include <ATen/ops/_foreach_addcmul_cpu_dispatch.h>
59
+ #include <ATen/ops/_foreach_asin_cpu_dispatch.h>
60
+ #include <ATen/ops/_foreach_atan_cpu_dispatch.h>
61
+ #include <ATen/ops/_foreach_ceil_cpu_dispatch.h>
62
+ #include <ATen/ops/_foreach_clamp_max_cpu_dispatch.h>
63
+ #include <ATen/ops/_foreach_clamp_min_cpu_dispatch.h>
64
+ #include <ATen/ops/_foreach_copy_cpu_dispatch.h>
65
+ #include <ATen/ops/_foreach_cos_cpu_dispatch.h>
66
+ #include <ATen/ops/_foreach_cosh_cpu_dispatch.h>
67
+ #include <ATen/ops/_foreach_div_cpu_dispatch.h>
68
+ #include <ATen/ops/_foreach_erf_cpu_dispatch.h>
69
+ #include <ATen/ops/_foreach_erfc_cpu_dispatch.h>
70
+ #include <ATen/ops/_foreach_exp_cpu_dispatch.h>
71
+ #include <ATen/ops/_foreach_expm1_cpu_dispatch.h>
72
+ #include <ATen/ops/_foreach_floor_cpu_dispatch.h>
73
+ #include <ATen/ops/_foreach_frac_cpu_dispatch.h>
74
+ #include <ATen/ops/_foreach_lerp_cpu_dispatch.h>
75
+ #include <ATen/ops/_foreach_lgamma_cpu_dispatch.h>
76
+ #include <ATen/ops/_foreach_log_cpu_dispatch.h>
77
+ #include <ATen/ops/_foreach_log10_cpu_dispatch.h>
78
+ #include <ATen/ops/_foreach_log1p_cpu_dispatch.h>
79
+ #include <ATen/ops/_foreach_log2_cpu_dispatch.h>
80
+ #include <ATen/ops/_foreach_maximum_cpu_dispatch.h>
81
+ #include <ATen/ops/_foreach_minimum_cpu_dispatch.h>
82
+ #include <ATen/ops/_foreach_mul_cpu_dispatch.h>
83
+ #include <ATen/ops/_foreach_neg_cpu_dispatch.h>
84
+ #include <ATen/ops/_foreach_norm_cpu_dispatch.h>
85
+ #include <ATen/ops/_foreach_pow_cpu_dispatch.h>
86
+ #include <ATen/ops/_foreach_reciprocal_cpu_dispatch.h>
87
+ #include <ATen/ops/_foreach_round_cpu_dispatch.h>
88
+ #include <ATen/ops/_foreach_sigmoid_cpu_dispatch.h>
89
+ #include <ATen/ops/_foreach_sign_cpu_dispatch.h>
90
+ #include <ATen/ops/_foreach_sin_cpu_dispatch.h>
91
+ #include <ATen/ops/_foreach_sinh_cpu_dispatch.h>
92
+ #include <ATen/ops/_foreach_sqrt_cpu_dispatch.h>
93
+ #include <ATen/ops/_foreach_sub_cpu_dispatch.h>
94
+ #include <ATen/ops/_foreach_tan_cpu_dispatch.h>
95
+ #include <ATen/ops/_foreach_tanh_cpu_dispatch.h>
96
+ #include <ATen/ops/_foreach_trunc_cpu_dispatch.h>
97
+ #include <ATen/ops/_foreach_zero_cpu_dispatch.h>
98
+ #include <ATen/ops/_functional_assert_async_cpu_dispatch.h>
99
+ #include <ATen/ops/_fused_moving_avg_obs_fq_helper_cpu_dispatch.h>
100
+ #include <ATen/ops/_fused_sdp_choice_cpu_dispatch.h>
101
+ #include <ATen/ops/_histogramdd_bin_edges_cpu_dispatch.h>
102
+ #include <ATen/ops/_histogramdd_from_bin_cts_cpu_dispatch.h>
103
+ #include <ATen/ops/_histogramdd_from_bin_tensors_cpu_dispatch.h>
104
+ #include <ATen/ops/_index_put_impl_cpu_dispatch.h>
105
+ #include <ATen/ops/_linalg_det_cpu_dispatch.h>
106
+ #include <ATen/ops/_linalg_eigh_cpu_dispatch.h>
107
+ #include <ATen/ops/_linalg_slogdet_cpu_dispatch.h>
108
+ #include <ATen/ops/_linalg_solve_ex_cpu_dispatch.h>
109
+ #include <ATen/ops/_linalg_svd_cpu_dispatch.h>
110
+ #include <ATen/ops/_local_scalar_dense_cpu_dispatch.h>
111
+ #include <ATen/ops/_log_softmax_cpu_dispatch.h>
112
+ #include <ATen/ops/_log_softmax_backward_data_cpu_dispatch.h>
113
+ #include <ATen/ops/_logcumsumexp_cpu_dispatch.h>
114
+ #include <ATen/ops/_make_dep_token_cpu_dispatch.h>
115
+ #include <ATen/ops/_make_per_channel_quantized_tensor_cpu_dispatch.h>
116
+ #include <ATen/ops/_make_per_tensor_quantized_tensor_cpu_dispatch.h>
117
+ #include <ATen/ops/_masked_softmax_cpu_dispatch.h>
118
+ #include <ATen/ops/_masked_softmax_backward_cpu_dispatch.h>
119
+ #include <ATen/ops/_native_batch_norm_legit_cpu_dispatch.h>
120
+ #include <ATen/ops/_native_multi_head_attention_cpu_dispatch.h>
121
+ #include <ATen/ops/_nested_from_padded_cpu_dispatch.h>
122
+ #include <ATen/ops/_nested_tensor_from_mask_cpu_dispatch.h>
123
+ #include <ATen/ops/_nested_tensor_from_mask_left_aligned_cpu_dispatch.h>
124
+ #include <ATen/ops/_nested_view_from_buffer_cpu_dispatch.h>
125
+ #include <ATen/ops/_pdist_backward_cpu_dispatch.h>
126
+ #include <ATen/ops/_pdist_forward_cpu_dispatch.h>
127
+ #include <ATen/ops/_prelu_kernel_cpu_dispatch.h>
128
+ #include <ATen/ops/_prelu_kernel_backward_cpu_dispatch.h>
129
+ #include <ATen/ops/_reshape_alias_cpu_dispatch.h>
130
+ #include <ATen/ops/_sample_dirichlet_cpu_dispatch.h>
131
+ #include <ATen/ops/_scaled_dot_product_flash_attention_cpu_dispatch.h>
132
+ #include <ATen/ops/_scaled_dot_product_flash_attention_backward_cpu_dispatch.h>
133
+ #include <ATen/ops/_segment_reduce_backward_cpu_dispatch.h>
134
+ #include <ATen/ops/_slow_conv2d_backward_cpu_dispatch.h>
135
+ #include <ATen/ops/_slow_conv2d_forward_cpu_dispatch.h>
136
+ #include <ATen/ops/_softmax_cpu_dispatch.h>
137
+ #include <ATen/ops/_softmax_backward_data_cpu_dispatch.h>
138
+ #include <ATen/ops/_spdiags_cpu_dispatch.h>
139
+ #include <ATen/ops/_stack_cpu_dispatch.h>
140
+ #include <ATen/ops/_standard_gamma_cpu_dispatch.h>
141
+ #include <ATen/ops/_standard_gamma_grad_cpu_dispatch.h>
142
+ #include <ATen/ops/_test_functorch_fallback_cpu_dispatch.h>
143
+ #include <ATen/ops/_test_optional_filled_intlist_cpu_dispatch.h>
144
+ #include <ATen/ops/_test_optional_floatlist_cpu_dispatch.h>
145
+ #include <ATen/ops/_test_optional_intlist_cpu_dispatch.h>
146
+ #include <ATen/ops/_to_sparse_cpu_dispatch.h>
147
+ #include <ATen/ops/_to_sparse_bsc_cpu_dispatch.h>
148
+ #include <ATen/ops/_to_sparse_bsr_cpu_dispatch.h>
149
+ #include <ATen/ops/_to_sparse_csc_cpu_dispatch.h>
150
+ #include <ATen/ops/_to_sparse_csr_cpu_dispatch.h>
151
+ #include <ATen/ops/_transform_bias_rescale_qkv_cpu_dispatch.h>
152
+ #include <ATen/ops/_transformer_encoder_layer_fwd_cpu_dispatch.h>
153
+ #include <ATen/ops/_unique_cpu_dispatch.h>
154
+ #include <ATen/ops/_unique2_cpu_dispatch.h>
155
+ #include <ATen/ops/_upsample_bicubic2d_aa_cpu_dispatch.h>
156
+ #include <ATen/ops/_upsample_bicubic2d_aa_backward_cpu_dispatch.h>
157
+ #include <ATen/ops/_upsample_bilinear2d_aa_cpu_dispatch.h>
158
+ #include <ATen/ops/_upsample_bilinear2d_aa_backward_cpu_dispatch.h>
159
+ #include <ATen/ops/_upsample_nearest_exact1d_cpu_dispatch.h>
160
+ #include <ATen/ops/_upsample_nearest_exact1d_backward_cpu_dispatch.h>
161
+ #include <ATen/ops/_upsample_nearest_exact2d_cpu_dispatch.h>
162
+ #include <ATen/ops/_upsample_nearest_exact2d_backward_cpu_dispatch.h>
163
+ #include <ATen/ops/_upsample_nearest_exact3d_cpu_dispatch.h>
164
+ #include <ATen/ops/_upsample_nearest_exact3d_backward_cpu_dispatch.h>
165
+ #include <ATen/ops/_validate_compressed_sparse_indices_cpu_dispatch.h>
166
+ #include <ATen/ops/_weight_norm_interface_cpu_dispatch.h>
167
+ #include <ATen/ops/_weight_norm_interface_backward_cpu_dispatch.h>
168
+ #include <ATen/ops/abs_cpu_dispatch.h>
169
+ #include <ATen/ops/acos_cpu_dispatch.h>
170
+ #include <ATen/ops/acosh_cpu_dispatch.h>
171
+ #include <ATen/ops/adaptive_avg_pool2d_cpu_dispatch.h>
172
+ #include <ATen/ops/adaptive_avg_pool3d_cpu_dispatch.h>
173
+ #include <ATen/ops/adaptive_avg_pool3d_backward_cpu_dispatch.h>
174
+ #include <ATen/ops/adaptive_max_pool2d_cpu_dispatch.h>
175
+ #include <ATen/ops/adaptive_max_pool2d_backward_cpu_dispatch.h>
176
+ #include <ATen/ops/adaptive_max_pool3d_cpu_dispatch.h>
177
+ #include <ATen/ops/adaptive_max_pool3d_backward_cpu_dispatch.h>
178
+ #include <ATen/ops/add_cpu_dispatch.h>
179
+ #include <ATen/ops/addbmm_cpu_dispatch.h>
180
+ #include <ATen/ops/addcdiv_cpu_dispatch.h>
181
+ #include <ATen/ops/addcmul_cpu_dispatch.h>
182
+ #include <ATen/ops/addmm_cpu_dispatch.h>
183
+ #include <ATen/ops/addmv_cpu_dispatch.h>
184
+ #include <ATen/ops/addr_cpu_dispatch.h>
185
+ #include <ATen/ops/all_cpu_dispatch.h>
186
+ #include <ATen/ops/amax_cpu_dispatch.h>
187
+ #include <ATen/ops/amin_cpu_dispatch.h>
188
+ #include <ATen/ops/aminmax_cpu_dispatch.h>
189
+ #include <ATen/ops/angle_cpu_dispatch.h>
190
+ #include <ATen/ops/any_cpu_dispatch.h>
191
+ #include <ATen/ops/arange_cpu_dispatch.h>
192
+ #include <ATen/ops/argmax_cpu_dispatch.h>
193
+ #include <ATen/ops/argmin_cpu_dispatch.h>
194
+ #include <ATen/ops/argsort_cpu_dispatch.h>
195
+ #include <ATen/ops/as_strided_cpu_dispatch.h>
196
+ #include <ATen/ops/asin_cpu_dispatch.h>
197
+ #include <ATen/ops/asinh_cpu_dispatch.h>
198
+ #include <ATen/ops/atan_cpu_dispatch.h>
199
+ #include <ATen/ops/atan2_cpu_dispatch.h>
200
+ #include <ATen/ops/atanh_cpu_dispatch.h>
201
+ #include <ATen/ops/avg_pool2d_cpu_dispatch.h>
202
+ #include <ATen/ops/avg_pool2d_backward_cpu_dispatch.h>
203
+ #include <ATen/ops/avg_pool3d_cpu_dispatch.h>
204
+ #include <ATen/ops/avg_pool3d_backward_cpu_dispatch.h>
205
+ #include <ATen/ops/baddbmm_cpu_dispatch.h>
206
+ #include <ATen/ops/batch_norm_update_stats_cpu_dispatch.h>
207
+ #include <ATen/ops/bernoulli_cpu_dispatch.h>
208
+ #include <ATen/ops/binary_cross_entropy_cpu_dispatch.h>
209
+ #include <ATen/ops/binary_cross_entropy_backward_cpu_dispatch.h>
210
+ #include <ATen/ops/bincount_cpu_dispatch.h>
211
+ #include <ATen/ops/binomial_cpu_dispatch.h>
212
+ #include <ATen/ops/bitwise_and_cpu_dispatch.h>
213
+ #include <ATen/ops/bitwise_left_shift_cpu_dispatch.h>
214
+ #include <ATen/ops/bitwise_not_cpu_dispatch.h>
215
+ #include <ATen/ops/bitwise_or_cpu_dispatch.h>
216
+ #include <ATen/ops/bitwise_right_shift_cpu_dispatch.h>
217
+ #include <ATen/ops/bitwise_xor_cpu_dispatch.h>
218
+ #include <ATen/ops/bmm_cpu_dispatch.h>
219
+ #include <ATen/ops/bucketize_cpu_dispatch.h>
220
+ #include <ATen/ops/cat_cpu_dispatch.h>
221
+ #include <ATen/ops/cauchy_cpu_dispatch.h>
222
+ #include <ATen/ops/ceil_cpu_dispatch.h>
223
+ #include <ATen/ops/channel_shuffle_cpu_dispatch.h>
224
+ #include <ATen/ops/cholesky_cpu_dispatch.h>
225
+ #include <ATen/ops/cholesky_inverse_cpu_dispatch.h>
226
+ #include <ATen/ops/clamp_cpu_dispatch.h>
227
+ #include <ATen/ops/clamp_max_cpu_dispatch.h>
228
+ #include <ATen/ops/clamp_min_cpu_dispatch.h>
229
+ #include <ATen/ops/col2im_cpu_dispatch.h>
230
+ #include <ATen/ops/complex_cpu_dispatch.h>
231
+ #include <ATen/ops/conj_physical_cpu_dispatch.h>
232
+ #include <ATen/ops/copysign_cpu_dispatch.h>
233
+ #include <ATen/ops/cos_cpu_dispatch.h>
234
+ #include <ATen/ops/cosh_cpu_dispatch.h>
235
+ #include <ATen/ops/count_nonzero_cpu_dispatch.h>
236
+ #include <ATen/ops/cumprod_cpu_dispatch.h>
237
+ #include <ATen/ops/cumsum_cpu_dispatch.h>
238
+ #include <ATen/ops/dense_dim_cpu_dispatch.h>
239
+ #include <ATen/ops/dequantize_cpu_dispatch.h>
240
+ #include <ATen/ops/digamma_cpu_dispatch.h>
241
+ #include <ATen/ops/div_cpu_dispatch.h>
242
+ #include <ATen/ops/dot_cpu_dispatch.h>
243
+ #include <ATen/ops/elu_cpu_dispatch.h>
244
+ #include <ATen/ops/elu_backward_cpu_dispatch.h>
245
+ #include <ATen/ops/embedding_dense_backward_cpu_dispatch.h>
246
+ #include <ATen/ops/embedding_renorm_cpu_dispatch.h>
247
+ #include <ATen/ops/empty_cpu_dispatch.h>
248
+ #include <ATen/ops/empty_strided_cpu_dispatch.h>
249
+ #include <ATen/ops/eq_cpu_dispatch.h>
250
+ #include <ATen/ops/equal_cpu_dispatch.h>
251
+ #include <ATen/ops/erf_cpu_dispatch.h>
252
+ #include <ATen/ops/erfc_cpu_dispatch.h>
253
+ #include <ATen/ops/erfinv_cpu_dispatch.h>
254
+ #include <ATen/ops/exp_cpu_dispatch.h>
255
+ #include <ATen/ops/exp2_cpu_dispatch.h>
256
+ #include <ATen/ops/expm1_cpu_dispatch.h>
257
+ #include <ATen/ops/exponential_cpu_dispatch.h>
258
+ #include <ATen/ops/eye_cpu_dispatch.h>
259
+ #include <ATen/ops/fake_quantize_per_channel_affine_cachemask_cpu_dispatch.h>
260
+ #include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_cpu_dispatch.h>
261
+ #include <ATen/ops/fill_cpu_dispatch.h>
262
+ #include <ATen/ops/flip_cpu_dispatch.h>
263
+ #include <ATen/ops/floor_cpu_dispatch.h>
264
+ #include <ATen/ops/floor_divide_cpu_dispatch.h>
265
+ #include <ATen/ops/fmax_cpu_dispatch.h>
266
+ #include <ATen/ops/fmin_cpu_dispatch.h>
267
+ #include <ATen/ops/fmod_cpu_dispatch.h>
268
+ #include <ATen/ops/frac_cpu_dispatch.h>
269
+ #include <ATen/ops/fractional_max_pool2d_cpu_dispatch.h>
270
+ #include <ATen/ops/fractional_max_pool2d_backward_cpu_dispatch.h>
271
+ #include <ATen/ops/fractional_max_pool3d_cpu_dispatch.h>
272
+ #include <ATen/ops/fractional_max_pool3d_backward_cpu_dispatch.h>
273
+ #include <ATen/ops/frexp_cpu_dispatch.h>
274
+ #include <ATen/ops/from_file_cpu_dispatch.h>
275
+ #include <ATen/ops/gather_cpu_dispatch.h>
276
+ #include <ATen/ops/gcd_cpu_dispatch.h>
277
+ #include <ATen/ops/ge_cpu_dispatch.h>
278
+ #include <ATen/ops/gelu_cpu_dispatch.h>
279
+ #include <ATen/ops/gelu_backward_cpu_dispatch.h>
280
+ #include <ATen/ops/geometric_cpu_dispatch.h>
281
+ #include <ATen/ops/geqrf_cpu_dispatch.h>
282
+ #include <ATen/ops/glu_cpu_dispatch.h>
283
+ #include <ATen/ops/glu_backward_cpu_dispatch.h>
284
+ #include <ATen/ops/glu_backward_jvp_cpu_dispatch.h>
285
+ #include <ATen/ops/glu_jvp_cpu_dispatch.h>
286
+ #include <ATen/ops/grid_sampler_2d_cpu_dispatch.h>
287
+ #include <ATen/ops/grid_sampler_2d_backward_cpu_dispatch.h>
288
+ #include <ATen/ops/grid_sampler_3d_cpu_dispatch.h>
289
+ #include <ATen/ops/grid_sampler_3d_backward_cpu_dispatch.h>
290
+ #include <ATen/ops/gt_cpu_dispatch.h>
291
+ #include <ATen/ops/hardshrink_cpu_dispatch.h>
292
+ #include <ATen/ops/hardshrink_backward_cpu_dispatch.h>
293
+ #include <ATen/ops/hardsigmoid_cpu_dispatch.h>
294
+ #include <ATen/ops/hardsigmoid_backward_cpu_dispatch.h>
295
+ #include <ATen/ops/hardswish_cpu_dispatch.h>
296
+ #include <ATen/ops/hardswish_backward_cpu_dispatch.h>
297
+ #include <ATen/ops/hardtanh_cpu_dispatch.h>
298
+ #include <ATen/ops/hardtanh_backward_cpu_dispatch.h>
299
+ #include <ATen/ops/heaviside_cpu_dispatch.h>
300
+ #include <ATen/ops/histc_cpu_dispatch.h>
301
+ #include <ATen/ops/histogram_cpu_dispatch.h>
302
+ #include <ATen/ops/huber_loss_cpu_dispatch.h>
303
+ #include <ATen/ops/huber_loss_backward_cpu_dispatch.h>
304
+ #include <ATen/ops/hypot_cpu_dispatch.h>
305
+ #include <ATen/ops/i0_cpu_dispatch.h>
306
+ #include <ATen/ops/igamma_cpu_dispatch.h>
307
+ #include <ATen/ops/igammac_cpu_dispatch.h>
308
+ #include <ATen/ops/im2col_cpu_dispatch.h>
309
+ #include <ATen/ops/index_cpu_dispatch.h>
310
+ #include <ATen/ops/index_add_cpu_dispatch.h>
311
+ #include <ATen/ops/index_copy_cpu_dispatch.h>
312
+ #include <ATen/ops/index_fill_cpu_dispatch.h>
313
+ #include <ATen/ops/index_reduce_cpu_dispatch.h>
314
+ #include <ATen/ops/index_select_cpu_dispatch.h>
315
+ #include <ATen/ops/is_set_to_cpu_dispatch.h>
316
+ #include <ATen/ops/isin_cpu_dispatch.h>
317
+ #include <ATen/ops/isnan_cpu_dispatch.h>
318
+ #include <ATen/ops/isneginf_cpu_dispatch.h>
319
+ #include <ATen/ops/isposinf_cpu_dispatch.h>
320
+ #include <ATen/ops/kthvalue_cpu_dispatch.h>
321
+ #include <ATen/ops/lcm_cpu_dispatch.h>
322
+ #include <ATen/ops/le_cpu_dispatch.h>
323
+ #include <ATen/ops/leaky_relu_cpu_dispatch.h>
324
+ #include <ATen/ops/leaky_relu_backward_cpu_dispatch.h>
325
+ #include <ATen/ops/lerp_cpu_dispatch.h>
326
+ #include <ATen/ops/lgamma_cpu_dispatch.h>
327
+ #include <ATen/ops/linalg_cholesky_ex_cpu_dispatch.h>
328
+ #include <ATen/ops/linalg_cross_cpu_dispatch.h>
329
+ #include <ATen/ops/linalg_eig_cpu_dispatch.h>
330
+ #include <ATen/ops/linalg_householder_product_cpu_dispatch.h>
331
+ #include <ATen/ops/linalg_inv_ex_cpu_dispatch.h>
332
+ #include <ATen/ops/linalg_ldl_factor_ex_cpu_dispatch.h>
333
+ #include <ATen/ops/linalg_ldl_solve_cpu_dispatch.h>
334
+ #include <ATen/ops/linalg_lstsq_cpu_dispatch.h>
335
+ #include <ATen/ops/linalg_lu_cpu_dispatch.h>
336
+ #include <ATen/ops/linalg_lu_factor_ex_cpu_dispatch.h>
337
+ #include <ATen/ops/linalg_lu_solve_cpu_dispatch.h>
338
+ #include <ATen/ops/linalg_matrix_exp_cpu_dispatch.h>
339
+ #include <ATen/ops/linalg_qr_cpu_dispatch.h>
340
+ #include <ATen/ops/linalg_solve_triangular_cpu_dispatch.h>
341
+ #include <ATen/ops/linalg_vector_norm_cpu_dispatch.h>
342
+ #include <ATen/ops/linspace_cpu_dispatch.h>
343
+ #include <ATen/ops/log_cpu_dispatch.h>
344
+ #include <ATen/ops/log10_cpu_dispatch.h>
345
+ #include <ATen/ops/log1p_cpu_dispatch.h>
346
+ #include <ATen/ops/log2_cpu_dispatch.h>
347
+ #include <ATen/ops/log_normal_cpu_dispatch.h>
348
+ #include <ATen/ops/log_sigmoid_backward_cpu_dispatch.h>
349
+ #include <ATen/ops/log_sigmoid_forward_cpu_dispatch.h>
350
+ #include <ATen/ops/logaddexp_cpu_dispatch.h>
351
+ #include <ATen/ops/logaddexp2_cpu_dispatch.h>
352
+ #include <ATen/ops/logical_and_cpu_dispatch.h>
353
+ #include <ATen/ops/logical_not_cpu_dispatch.h>
354
+ #include <ATen/ops/logical_or_cpu_dispatch.h>
355
+ #include <ATen/ops/logical_xor_cpu_dispatch.h>
356
+ #include <ATen/ops/logit_cpu_dispatch.h>
357
+ #include <ATen/ops/logit_backward_cpu_dispatch.h>
358
+ #include <ATen/ops/logspace_cpu_dispatch.h>
359
+ #include <ATen/ops/lshift_cpu_dispatch.h>
360
+ #include <ATen/ops/lt_cpu_dispatch.h>
361
+ #include <ATen/ops/lu_unpack_cpu_dispatch.h>
362
+ #include <ATen/ops/masked_fill_cpu_dispatch.h>
363
+ #include <ATen/ops/masked_scatter_cpu_dispatch.h>
364
+ #include <ATen/ops/masked_select_cpu_dispatch.h>
365
+ #include <ATen/ops/max_cpu_dispatch.h>
366
+ #include <ATen/ops/max_pool2d_with_indices_cpu_dispatch.h>
367
+ #include <ATen/ops/max_pool2d_with_indices_backward_cpu_dispatch.h>
368
+ #include <ATen/ops/max_pool3d_with_indices_cpu_dispatch.h>
369
+ #include <ATen/ops/max_pool3d_with_indices_backward_cpu_dispatch.h>
370
+ #include <ATen/ops/max_unpool2d_cpu_dispatch.h>
371
+ #include <ATen/ops/max_unpool3d_cpu_dispatch.h>
372
+ #include <ATen/ops/maximum_cpu_dispatch.h>
373
+ #include <ATen/ops/mean_cpu_dispatch.h>
374
+ #include <ATen/ops/median_cpu_dispatch.h>
375
+ #include <ATen/ops/min_cpu_dispatch.h>
376
+ #include <ATen/ops/minimum_cpu_dispatch.h>
377
+ #include <ATen/ops/mish_cpu_dispatch.h>
378
+ #include <ATen/ops/mish_backward_cpu_dispatch.h>
379
+ #include <ATen/ops/mkldnn_rnn_layer_cpu_dispatch.h>
380
+ #include <ATen/ops/mkldnn_rnn_layer_backward_cpu_dispatch.h>
381
+ #include <ATen/ops/mm_cpu_dispatch.h>
382
+ #include <ATen/ops/mode_cpu_dispatch.h>
383
+ #include <ATen/ops/mse_loss_cpu_dispatch.h>
384
+ #include <ATen/ops/mse_loss_backward_cpu_dispatch.h>
385
+ #include <ATen/ops/mul_cpu_dispatch.h>
386
+ #include <ATen/ops/multi_margin_loss_cpu_dispatch.h>
387
+ #include <ATen/ops/multi_margin_loss_backward_cpu_dispatch.h>
388
+ #include <ATen/ops/multilabel_margin_loss_backward_cpu_dispatch.h>
389
+ #include <ATen/ops/multilabel_margin_loss_forward_cpu_dispatch.h>
390
+ #include <ATen/ops/multinomial_cpu_dispatch.h>
391
+ #include <ATen/ops/mvlgamma_cpu_dispatch.h>
392
+ #include <ATen/ops/nan_to_num_cpu_dispatch.h>
393
+ #include <ATen/ops/nanmedian_cpu_dispatch.h>
394
+ #include <ATen/ops/nansum_cpu_dispatch.h>
395
+ #include <ATen/ops/narrow_copy_cpu_dispatch.h>
396
+ #include <ATen/ops/native_batch_norm_cpu_dispatch.h>
397
+ #include <ATen/ops/native_batch_norm_backward_cpu_dispatch.h>
398
+ #include <ATen/ops/native_channel_shuffle_cpu_dispatch.h>
399
+ #include <ATen/ops/native_dropout_cpu_dispatch.h>
400
+ #include <ATen/ops/native_dropout_backward_cpu_dispatch.h>
401
+ #include <ATen/ops/native_group_norm_cpu_dispatch.h>
402
+ #include <ATen/ops/native_group_norm_backward_cpu_dispatch.h>
403
+ #include <ATen/ops/native_layer_norm_cpu_dispatch.h>
404
+ #include <ATen/ops/native_layer_norm_backward_cpu_dispatch.h>
405
+ #include <ATen/ops/ne_cpu_dispatch.h>
406
+ #include <ATen/ops/neg_cpu_dispatch.h>
407
+ #include <ATen/ops/nextafter_cpu_dispatch.h>
408
+ #include <ATen/ops/nll_loss2d_backward_cpu_dispatch.h>
409
+ #include <ATen/ops/nll_loss2d_forward_cpu_dispatch.h>
410
+ #include <ATen/ops/nll_loss_backward_cpu_dispatch.h>
411
+ #include <ATen/ops/nll_loss_forward_cpu_dispatch.h>
412
+ #include <ATen/ops/nonzero_cpu_dispatch.h>
413
+ #include <ATen/ops/nonzero_static_cpu_dispatch.h>
414
+ #include <ATen/ops/norm_cpu_dispatch.h>
415
+ #include <ATen/ops/normal_cpu_dispatch.h>
416
+ #include <ATen/ops/ormqr_cpu_dispatch.h>
417
+ #include <ATen/ops/pixel_shuffle_cpu_dispatch.h>
418
+ #include <ATen/ops/pixel_unshuffle_cpu_dispatch.h>
419
+ #include <ATen/ops/poisson_cpu_dispatch.h>
420
+ #include <ATen/ops/polar_cpu_dispatch.h>
421
+ #include <ATen/ops/polygamma_cpu_dispatch.h>
422
+ #include <ATen/ops/pow_cpu_dispatch.h>
423
+ #include <ATen/ops/prod_cpu_dispatch.h>
424
+ #include <ATen/ops/put_cpu_dispatch.h>
425
+ #include <ATen/ops/quantize_per_channel_cpu_dispatch.h>
426
+ #include <ATen/ops/quantize_per_tensor_cpu_dispatch.h>
427
+ #include <ATen/ops/quantize_per_tensor_dynamic_cpu_dispatch.h>
428
+ #include <ATen/ops/random_cpu_dispatch.h>
429
+ #include <ATen/ops/randperm_cpu_dispatch.h>
430
+ #include <ATen/ops/range_cpu_dispatch.h>
431
+ #include <ATen/ops/reciprocal_cpu_dispatch.h>
432
+ #include <ATen/ops/reflection_pad1d_cpu_dispatch.h>
433
+ #include <ATen/ops/reflection_pad1d_backward_cpu_dispatch.h>
434
+ #include <ATen/ops/reflection_pad2d_cpu_dispatch.h>
435
+ #include <ATen/ops/reflection_pad2d_backward_cpu_dispatch.h>
436
+ #include <ATen/ops/reflection_pad3d_cpu_dispatch.h>
437
+ #include <ATen/ops/reflection_pad3d_backward_cpu_dispatch.h>
438
+ #include <ATen/ops/relu_cpu_dispatch.h>
439
+ #include <ATen/ops/remainder_cpu_dispatch.h>
440
+ #include <ATen/ops/renorm_cpu_dispatch.h>
441
+ #include <ATen/ops/repeat_interleave_cpu_dispatch.h>
442
+ #include <ATen/ops/replication_pad1d_cpu_dispatch.h>
443
+ #include <ATen/ops/replication_pad1d_backward_cpu_dispatch.h>
444
+ #include <ATen/ops/replication_pad2d_cpu_dispatch.h>
445
+ #include <ATen/ops/replication_pad2d_backward_cpu_dispatch.h>
446
+ #include <ATen/ops/replication_pad3d_cpu_dispatch.h>
447
+ #include <ATen/ops/replication_pad3d_backward_cpu_dispatch.h>
448
+ #include <ATen/ops/resize_cpu_dispatch.h>
449
+ #include <ATen/ops/roll_cpu_dispatch.h>
450
+ #include <ATen/ops/round_cpu_dispatch.h>
451
+ #include <ATen/ops/rrelu_with_noise_cpu_dispatch.h>
452
+ #include <ATen/ops/rshift_cpu_dispatch.h>
453
+ #include <ATen/ops/rsqrt_cpu_dispatch.h>
454
+ #include <ATen/ops/rsub_cpu_dispatch.h>
455
+ #include <ATen/ops/scatter_cpu_dispatch.h>
456
+ #include <ATen/ops/scatter_add_cpu_dispatch.h>
457
+ #include <ATen/ops/scatter_reduce_cpu_dispatch.h>
458
+ #include <ATen/ops/searchsorted_cpu_dispatch.h>
459
+ #include <ATen/ops/segment_reduce_cpu_dispatch.h>
460
+ #include <ATen/ops/set_cpu_dispatch.h>
461
+ #include <ATen/ops/sgn_cpu_dispatch.h>
462
+ #include <ATen/ops/sigmoid_cpu_dispatch.h>
463
+ #include <ATen/ops/sigmoid_backward_cpu_dispatch.h>
464
+ #include <ATen/ops/sign_cpu_dispatch.h>
465
+ #include <ATen/ops/signbit_cpu_dispatch.h>
466
+ #include <ATen/ops/silu_cpu_dispatch.h>
467
+ #include <ATen/ops/silu_backward_cpu_dispatch.h>
468
+ #include <ATen/ops/sin_cpu_dispatch.h>
469
+ #include <ATen/ops/sinc_cpu_dispatch.h>
470
+ #include <ATen/ops/sinh_cpu_dispatch.h>
471
+ #include <ATen/ops/slow_conv3d_forward_cpu_dispatch.h>
472
+ #include <ATen/ops/slow_conv_dilated2d_cpu_dispatch.h>
473
+ #include <ATen/ops/slow_conv_dilated3d_cpu_dispatch.h>
474
+ #include <ATen/ops/slow_conv_transpose2d_cpu_dispatch.h>
475
+ #include <ATen/ops/slow_conv_transpose3d_cpu_dispatch.h>
476
+ #include <ATen/ops/smooth_l1_loss_cpu_dispatch.h>
477
+ #include <ATen/ops/smooth_l1_loss_backward_cpu_dispatch.h>
478
+ #include <ATen/ops/softplus_cpu_dispatch.h>
479
+ #include <ATen/ops/softplus_backward_cpu_dispatch.h>
480
+ #include <ATen/ops/softshrink_cpu_dispatch.h>
481
+ #include <ATen/ops/softshrink_backward_cpu_dispatch.h>
482
+ #include <ATen/ops/sort_cpu_dispatch.h>
483
+ #include <ATen/ops/sparse_dim_cpu_dispatch.h>
484
+ #include <ATen/ops/special_airy_ai_cpu_dispatch.h>
485
+ #include <ATen/ops/special_bessel_j0_cpu_dispatch.h>
486
+ #include <ATen/ops/special_bessel_j1_cpu_dispatch.h>
487
+ #include <ATen/ops/special_bessel_y0_cpu_dispatch.h>
488
+ #include <ATen/ops/special_bessel_y1_cpu_dispatch.h>
489
+ #include <ATen/ops/special_chebyshev_polynomial_t_cpu_dispatch.h>
490
+ #include <ATen/ops/special_chebyshev_polynomial_u_cpu_dispatch.h>
491
+ #include <ATen/ops/special_chebyshev_polynomial_v_cpu_dispatch.h>
492
+ #include <ATen/ops/special_chebyshev_polynomial_w_cpu_dispatch.h>
493
+ #include <ATen/ops/special_entr_cpu_dispatch.h>
494
+ #include <ATen/ops/special_erfcx_cpu_dispatch.h>
495
+ #include <ATen/ops/special_hermite_polynomial_h_cpu_dispatch.h>
496
+ #include <ATen/ops/special_hermite_polynomial_he_cpu_dispatch.h>
497
+ #include <ATen/ops/special_i0e_cpu_dispatch.h>
498
+ #include <ATen/ops/special_i1_cpu_dispatch.h>
499
+ #include <ATen/ops/special_i1e_cpu_dispatch.h>
500
+ #include <ATen/ops/special_laguerre_polynomial_l_cpu_dispatch.h>
501
+ #include <ATen/ops/special_legendre_polynomial_p_cpu_dispatch.h>
502
+ #include <ATen/ops/special_log_ndtr_cpu_dispatch.h>
503
+ #include <ATen/ops/special_modified_bessel_i0_cpu_dispatch.h>
504
+ #include <ATen/ops/special_modified_bessel_i1_cpu_dispatch.h>
505
+ #include <ATen/ops/special_modified_bessel_k0_cpu_dispatch.h>
506
+ #include <ATen/ops/special_modified_bessel_k1_cpu_dispatch.h>
507
+ #include <ATen/ops/special_ndtri_cpu_dispatch.h>
508
+ #include <ATen/ops/special_scaled_modified_bessel_k0_cpu_dispatch.h>
509
+ #include <ATen/ops/special_scaled_modified_bessel_k1_cpu_dispatch.h>
510
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_t_cpu_dispatch.h>
511
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_u_cpu_dispatch.h>
512
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_v_cpu_dispatch.h>
513
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_w_cpu_dispatch.h>
514
+ #include <ATen/ops/special_spherical_bessel_j0_cpu_dispatch.h>
515
+ #include <ATen/ops/special_xlog1py_cpu_dispatch.h>
516
+ #include <ATen/ops/special_zeta_cpu_dispatch.h>
517
+ #include <ATen/ops/sqrt_cpu_dispatch.h>
518
+ #include <ATen/ops/sspaddmm_cpu_dispatch.h>
519
+ #include <ATen/ops/std_cpu_dispatch.h>
520
+ #include <ATen/ops/std_mean_cpu_dispatch.h>
521
+ #include <ATen/ops/sub_cpu_dispatch.h>
522
+ #include <ATen/ops/sum_cpu_dispatch.h>
523
+ #include <ATen/ops/take_cpu_dispatch.h>
524
+ #include <ATen/ops/tan_cpu_dispatch.h>
525
+ #include <ATen/ops/tanh_cpu_dispatch.h>
526
+ #include <ATen/ops/tanh_backward_cpu_dispatch.h>
527
+ #include <ATen/ops/threshold_cpu_dispatch.h>
528
+ #include <ATen/ops/threshold_backward_cpu_dispatch.h>
529
+ #include <ATen/ops/to_mkldnn_cpu_dispatch.h>
530
+ #include <ATen/ops/topk_cpu_dispatch.h>
531
+ #include <ATen/ops/trace_cpu_dispatch.h>
532
+ #include <ATen/ops/triangular_solve_cpu_dispatch.h>
533
+ #include <ATen/ops/tril_cpu_dispatch.h>
534
+ #include <ATen/ops/tril_indices_cpu_dispatch.h>
535
+ #include <ATen/ops/triu_cpu_dispatch.h>
536
+ #include <ATen/ops/triu_indices_cpu_dispatch.h>
537
+ #include <ATen/ops/trunc_cpu_dispatch.h>
538
+ #include <ATen/ops/unfold_cpu_dispatch.h>
539
+ #include <ATen/ops/unfold_backward_cpu_dispatch.h>
540
+ #include <ATen/ops/uniform_cpu_dispatch.h>
541
+ #include <ATen/ops/unique_consecutive_cpu_dispatch.h>
542
+ #include <ATen/ops/unique_dim_cpu_dispatch.h>
543
+ #include <ATen/ops/unique_dim_consecutive_cpu_dispatch.h>
544
+ #include <ATen/ops/upsample_bicubic2d_cpu_dispatch.h>
545
+ #include <ATen/ops/upsample_bicubic2d_backward_cpu_dispatch.h>
546
+ #include <ATen/ops/upsample_bilinear2d_cpu_dispatch.h>
547
+ #include <ATen/ops/upsample_bilinear2d_backward_cpu_dispatch.h>
548
+ #include <ATen/ops/upsample_linear1d_cpu_dispatch.h>
549
+ #include <ATen/ops/upsample_linear1d_backward_cpu_dispatch.h>
550
+ #include <ATen/ops/upsample_nearest1d_cpu_dispatch.h>
551
+ #include <ATen/ops/upsample_nearest1d_backward_cpu_dispatch.h>
552
+ #include <ATen/ops/upsample_nearest2d_cpu_dispatch.h>
553
+ #include <ATen/ops/upsample_nearest2d_backward_cpu_dispatch.h>
554
+ #include <ATen/ops/upsample_nearest3d_cpu_dispatch.h>
555
+ #include <ATen/ops/upsample_nearest3d_backward_cpu_dispatch.h>
556
+ #include <ATen/ops/upsample_trilinear3d_cpu_dispatch.h>
557
+ #include <ATen/ops/upsample_trilinear3d_backward_cpu_dispatch.h>
558
+ #include <ATen/ops/var_cpu_dispatch.h>
559
+ #include <ATen/ops/var_mean_cpu_dispatch.h>
560
+ #include <ATen/ops/vdot_cpu_dispatch.h>
561
+ #include <ATen/ops/view_cpu_dispatch.h>
562
+ #include <ATen/ops/view_as_complex_cpu_dispatch.h>
563
+ #include <ATen/ops/view_as_real_cpu_dispatch.h>
564
+ #include <ATen/ops/where_cpu_dispatch.h>
565
+ #include <ATen/ops/xlogy_cpu_dispatch.h>
566
+ #include <ATen/ops/zero_cpu_dispatch.h>
567
+
568
+
569
+
videollama2/lib/python3.10/site-packages/torch/include/ATen/CUDAFunctions.h ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #include <ATen/core/TensorBody.h>
2
+
3
+ // TODO Undo all logic introduced for Note [Avoiding Include Cycles In Static Dispatch]
4
+ // Code introduced to avoid cyclic dependency in static dispatch is no longer
5
+ // needed as static dispatch logic is moved from TensorBody.h, which caused cycles in the first place,
6
+ // to Operators.cpp for supporting multiple backends with multiple kernels.
7
+ //
8
+ // Note [Avoiding Include Cycles In Static Dispatch]
9
+ // In order to avoid #include cycles in the static dispatch build, we've carefully split out
10
+ // the static function definition files into {DispatchKey}Functions.h and {DispatchKey}Functions_inl.h.
11
+ //
12
+ // Without this split, the include cycle looks like TensorBody.h -> CPUFunctions.h -> TensorBody.h.
13
+ // - TensorBody.h #includes CPUFunctions.h in the static dispatch build, because the tensor methods
14
+ // all need to call into the fastpath C++ API defined in CPUFunctions.h. The methods are also all
15
+ // directly inlined into TensorBody.h.
16
+ // - CPUFunctions.h #includes TensorBody.h because it contains function declarations for the entire C++ API,
17
+ // which include functions that have defaultable optional<Tensor> arguments.
18
+ // That requires knowing the full Tensor class definition.
19
+ //
20
+ // We break the cycle by doing the following:
21
+ // - Split out CPUFunction.h into two files: CPUFunctions.h and CPUFunctions_inl.h
22
+ // - CPUFunction.h is a dummy file that just includes the Tensor class and includes CPUFunctions_inl.,
23
+ // - CPUFunctions_inl.h includes everything else
24
+ // - (only in the static dispatch build) TensorBody.h makes sure to finish defining the Tensor class,
25
+ // and then it includes CPUFunctions_inl.h.
26
+ // - All other files that want the cpu fastpath functions can include CPUFunctions.h directly.
27
+ // - This also means that static dispatch build, CPUFunctions.h only needs to
28
+ // #include TensorBody.h, and it will automatically bring in CPUFunctions_inl.h.
29
+ #include <ATen/CUDAFunctions_inl.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradFunctions.h ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #include <ATen/core/TensorBody.h>
2
+
3
+ // TODO Undo all logic introduced for Note [Avoiding Include Cycles In Static Dispatch]
4
+ // Code introduced to avoid cyclic dependency in static dispatch is no longer
5
+ // needed as static dispatch logic is moved from TensorBody.h, which caused cycles in the first place,
6
+ // to Operators.cpp for supporting multiple backends with multiple kernels.
7
+ //
8
+ // Note [Avoiding Include Cycles In Static Dispatch]
9
+ // In order to avoid #include cycles in the static dispatch build, we've carefully split out
10
+ // the static function definition files into {DispatchKey}Functions.h and {DispatchKey}Functions_inl.h.
11
+ //
12
+ // Without this split, the include cycle looks like TensorBody.h -> CPUFunctions.h -> TensorBody.h.
13
+ // - TensorBody.h #includes CPUFunctions.h in the static dispatch build, because the tensor methods
14
+ // all need to call into the fastpath C++ API defined in CPUFunctions.h. The methods are also all
15
+ // directly inlined into TensorBody.h.
16
+ // - CPUFunctions.h #includes TensorBody.h because it contains function declarations for the entire C++ API,
17
+ // which include functions that have defaultable optional<Tensor> arguments.
18
+ // That requires knowing the full Tensor class definition.
19
+ //
20
+ // We break the cycle by doing the following:
21
+ // - Split out CPUFunction.h into two files: CPUFunctions.h and CPUFunctions_inl.h
22
+ // - CPUFunction.h is a dummy file that just includes the Tensor class and includes CPUFunctions_inl.,
23
+ // - CPUFunctions_inl.h includes everything else
24
+ // - (only in the static dispatch build) TensorBody.h makes sure to finish defining the Tensor class,
25
+ // and then it includes CPUFunctions_inl.h.
26
+ // - All other files that want the cpu fastpath functions can include CPUFunctions.h directly.
27
+ // - This also means that static dispatch build, CPUFunctions.h only needs to
28
+ // #include TensorBody.h, and it will automatically bring in CPUFunctions_inl.h.
29
+ #include <ATen/CompositeImplicitAutogradFunctions_inl.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradFunctions_inl.h ADDED
@@ -0,0 +1,500 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunctions_inl.h
3
+
4
+ // NB: The implementing C++ file is RegisterDispatchKey.cpp
5
+
6
+ // The only #includes we need are for custom classes that have defaults in the C++ API
7
+ #include <c10/core/MemoryFormat.h>
8
+ #include <c10/core/Scalar.h>
9
+ #include <ATen/core/Reduction.h>
10
+
11
+ #if defined(AT_PER_OPERATOR_HEADERS) && defined(TORCH_ASSERT_ONLY_METHOD_OPERATORS)
12
+ #error This change adds a dependency on all pytorch operators, meaning the \
13
+ file will need to be re-compiled every time an operator is changed or added. \
14
+ Consider including a specific operator from \
15
+ <ATen/ops/{my_operator}_compositeimplicitautograd_dispatch.h>. \
16
+ See NOTE [TORCH_ASSERT_ONLY_METHOD_OPERATORS].
17
+ #endif
18
+
19
+ #include <ATen/ops/_add_batch_dim_compositeimplicitautograd_dispatch.h>
20
+ #include <ATen/ops/_assert_tensor_metadata_compositeimplicitautograd_dispatch.h>
21
+ #include <ATen/ops/_autocast_to_full_precision_compositeimplicitautograd_dispatch.h>
22
+ #include <ATen/ops/_autocast_to_reduced_precision_compositeimplicitautograd_dispatch.h>
23
+ #include <ATen/ops/_backward_compositeimplicitautograd_dispatch.h>
24
+ #include <ATen/ops/_batch_norm_impl_index_compositeimplicitautograd_dispatch.h>
25
+ #include <ATen/ops/_batch_norm_impl_index_backward_compositeimplicitautograd_dispatch.h>
26
+ #include <ATen/ops/_cast_Byte_compositeimplicitautograd_dispatch.h>
27
+ #include <ATen/ops/_cast_Char_compositeimplicitautograd_dispatch.h>
28
+ #include <ATen/ops/_cast_Double_compositeimplicitautograd_dispatch.h>
29
+ #include <ATen/ops/_cast_Float_compositeimplicitautograd_dispatch.h>
30
+ #include <ATen/ops/_cast_Half_compositeimplicitautograd_dispatch.h>
31
+ #include <ATen/ops/_cast_Int_compositeimplicitautograd_dispatch.h>
32
+ #include <ATen/ops/_cast_Long_compositeimplicitautograd_dispatch.h>
33
+ #include <ATen/ops/_cast_Short_compositeimplicitautograd_dispatch.h>
34
+ #include <ATen/ops/_choose_qparams_per_tensor_compositeimplicitautograd_dispatch.h>
35
+ #include <ATen/ops/_convolution_compositeimplicitautograd_dispatch.h>
36
+ #include <ATen/ops/_convolution_double_backward_compositeimplicitautograd_dispatch.h>
37
+ #include <ATen/ops/_convolution_mode_compositeimplicitautograd_dispatch.h>
38
+ #include <ATen/ops/_cufft_clear_plan_cache_compositeimplicitautograd_dispatch.h>
39
+ #include <ATen/ops/_cufft_get_plan_cache_max_size_compositeimplicitautograd_dispatch.h>
40
+ #include <ATen/ops/_cufft_get_plan_cache_size_compositeimplicitautograd_dispatch.h>
41
+ #include <ATen/ops/_cufft_set_plan_cache_max_size_compositeimplicitautograd_dispatch.h>
42
+ #include <ATen/ops/_debug_has_internal_overlap_compositeimplicitautograd_dispatch.h>
43
+ #include <ATen/ops/_dim_arange_compositeimplicitautograd_dispatch.h>
44
+ #include <ATen/ops/_embedding_bag_backward_compositeimplicitautograd_dispatch.h>
45
+ #include <ATen/ops/_embedding_bag_sparse_backward_compositeimplicitautograd_dispatch.h>
46
+ #include <ATen/ops/_gather_sparse_backward_compositeimplicitautograd_dispatch.h>
47
+ #include <ATen/ops/_grid_sampler_2d_cpu_fallback_backward_compositeimplicitautograd_dispatch.h>
48
+ #include <ATen/ops/_has_compatible_shallow_copy_type_compositeimplicitautograd_dispatch.h>
49
+ #include <ATen/ops/_is_zerotensor_compositeimplicitautograd_dispatch.h>
50
+ #include <ATen/ops/_lu_with_info_compositeimplicitautograd_dispatch.h>
51
+ #include <ATen/ops/_nnpack_available_compositeimplicitautograd_dispatch.h>
52
+ #include <ATen/ops/_pack_padded_sequence_backward_compositeimplicitautograd_dispatch.h>
53
+ #include <ATen/ops/_pad_circular_compositeimplicitautograd_dispatch.h>
54
+ #include <ATen/ops/_pad_enum_compositeimplicitautograd_dispatch.h>
55
+ #include <ATen/ops/_pad_packed_sequence_compositeimplicitautograd_dispatch.h>
56
+ #include <ATen/ops/_propagate_xla_data_compositeimplicitautograd_dispatch.h>
57
+ #include <ATen/ops/_remove_batch_dim_compositeimplicitautograd_dispatch.h>
58
+ #include <ATen/ops/_reshape_from_tensor_compositeimplicitautograd_dispatch.h>
59
+ #include <ATen/ops/_rowwise_prune_compositeimplicitautograd_dispatch.h>
60
+ #include <ATen/ops/_saturate_weight_to_fp16_compositeimplicitautograd_dispatch.h>
61
+ #include <ATen/ops/_scaled_dot_product_attention_math_compositeimplicitautograd_dispatch.h>
62
+ #include <ATen/ops/_shape_as_tensor_compositeimplicitautograd_dispatch.h>
63
+ #include <ATen/ops/_sobol_engine_draw_compositeimplicitautograd_dispatch.h>
64
+ #include <ATen/ops/_sobol_engine_ff_compositeimplicitautograd_dispatch.h>
65
+ #include <ATen/ops/_sobol_engine_initialize_state_compositeimplicitautograd_dispatch.h>
66
+ #include <ATen/ops/_sobol_engine_scramble_compositeimplicitautograd_dispatch.h>
67
+ #include <ATen/ops/_sparse_bsc_tensor_unsafe_compositeimplicitautograd_dispatch.h>
68
+ #include <ATen/ops/_sparse_bsr_tensor_unsafe_compositeimplicitautograd_dispatch.h>
69
+ #include <ATen/ops/_sparse_compressed_tensor_unsafe_compositeimplicitautograd_dispatch.h>
70
+ #include <ATen/ops/_sparse_coo_tensor_unsafe_compositeimplicitautograd_dispatch.h>
71
+ #include <ATen/ops/_sparse_csc_tensor_unsafe_compositeimplicitautograd_dispatch.h>
72
+ #include <ATen/ops/_sparse_csr_tensor_unsafe_compositeimplicitautograd_dispatch.h>
73
+ #include <ATen/ops/_sparse_log_softmax_compositeimplicitautograd_dispatch.h>
74
+ #include <ATen/ops/_sparse_mm_compositeimplicitautograd_dispatch.h>
75
+ #include <ATen/ops/_sparse_softmax_compositeimplicitautograd_dispatch.h>
76
+ #include <ATen/ops/_sparse_sum_compositeimplicitautograd_dispatch.h>
77
+ #include <ATen/ops/_test_ambiguous_defaults_compositeimplicitautograd_dispatch.h>
78
+ #include <ATen/ops/_test_autograd_multiple_dispatch_compositeimplicitautograd_dispatch.h>
79
+ #include <ATen/ops/_test_check_tensor_compositeimplicitautograd_dispatch.h>
80
+ #include <ATen/ops/_test_serialization_subcmul_compositeimplicitautograd_dispatch.h>
81
+ #include <ATen/ops/_test_string_default_compositeimplicitautograd_dispatch.h>
82
+ #include <ATen/ops/_thnn_differentiable_gru_cell_backward_compositeimplicitautograd_dispatch.h>
83
+ #include <ATen/ops/_thnn_differentiable_lstm_cell_backward_compositeimplicitautograd_dispatch.h>
84
+ #include <ATen/ops/_thnn_fused_lstm_cell_backward_compositeimplicitautograd_dispatch.h>
85
+ #include <ATen/ops/_to_cpu_compositeimplicitautograd_dispatch.h>
86
+ #include <ATen/ops/_unpack_dual_compositeimplicitautograd_dispatch.h>
87
+ #include <ATen/ops/_upsample_bicubic2d_aa_compositeimplicitautograd_dispatch.h>
88
+ #include <ATen/ops/_upsample_bilinear2d_aa_compositeimplicitautograd_dispatch.h>
89
+ #include <ATen/ops/_upsample_nearest_exact1d_compositeimplicitautograd_dispatch.h>
90
+ #include <ATen/ops/_upsample_nearest_exact2d_compositeimplicitautograd_dispatch.h>
91
+ #include <ATen/ops/_upsample_nearest_exact3d_compositeimplicitautograd_dispatch.h>
92
+ #include <ATen/ops/_use_cudnn_rnn_flatten_weight_compositeimplicitautograd_dispatch.h>
93
+ #include <ATen/ops/_validate_sparse_bsc_tensor_args_compositeimplicitautograd_dispatch.h>
94
+ #include <ATen/ops/_validate_sparse_bsr_tensor_args_compositeimplicitautograd_dispatch.h>
95
+ #include <ATen/ops/_validate_sparse_compressed_tensor_args_compositeimplicitautograd_dispatch.h>
96
+ #include <ATen/ops/_validate_sparse_coo_tensor_args_compositeimplicitautograd_dispatch.h>
97
+ #include <ATen/ops/_validate_sparse_csc_tensor_args_compositeimplicitautograd_dispatch.h>
98
+ #include <ATen/ops/_validate_sparse_csr_tensor_args_compositeimplicitautograd_dispatch.h>
99
+ #include <ATen/ops/_version_compositeimplicitautograd_dispatch.h>
100
+ #include <ATen/ops/_weight_norm_compositeimplicitautograd_dispatch.h>
101
+ #include <ATen/ops/_weight_norm_differentiable_backward_compositeimplicitautograd_dispatch.h>
102
+ #include <ATen/ops/absolute_compositeimplicitautograd_dispatch.h>
103
+ #include <ATen/ops/adaptive_avg_pool1d_compositeimplicitautograd_dispatch.h>
104
+ #include <ATen/ops/adaptive_avg_pool2d_compositeimplicitautograd_dispatch.h>
105
+ #include <ATen/ops/adaptive_avg_pool3d_compositeimplicitautograd_dispatch.h>
106
+ #include <ATen/ops/adaptive_max_pool1d_compositeimplicitautograd_dispatch.h>
107
+ #include <ATen/ops/adjoint_compositeimplicitautograd_dispatch.h>
108
+ #include <ATen/ops/affine_grid_generator_backward_compositeimplicitautograd_dispatch.h>
109
+ #include <ATen/ops/align_as_compositeimplicitautograd_dispatch.h>
110
+ #include <ATen/ops/align_tensors_compositeimplicitautograd_dispatch.h>
111
+ #include <ATen/ops/align_to_compositeimplicitautograd_dispatch.h>
112
+ #include <ATen/ops/all_compositeimplicitautograd_dispatch.h>
113
+ #include <ATen/ops/alpha_dropout_compositeimplicitautograd_dispatch.h>
114
+ #include <ATen/ops/and_compositeimplicitautograd_dispatch.h>
115
+ #include <ATen/ops/any_compositeimplicitautograd_dispatch.h>
116
+ #include <ATen/ops/arccos_compositeimplicitautograd_dispatch.h>
117
+ #include <ATen/ops/arccosh_compositeimplicitautograd_dispatch.h>
118
+ #include <ATen/ops/arcsin_compositeimplicitautograd_dispatch.h>
119
+ #include <ATen/ops/arcsinh_compositeimplicitautograd_dispatch.h>
120
+ #include <ATen/ops/arctan_compositeimplicitautograd_dispatch.h>
121
+ #include <ATen/ops/arctan2_compositeimplicitautograd_dispatch.h>
122
+ #include <ATen/ops/arctanh_compositeimplicitautograd_dispatch.h>
123
+ #include <ATen/ops/argsort_compositeimplicitautograd_dispatch.h>
124
+ #include <ATen/ops/argwhere_compositeimplicitautograd_dispatch.h>
125
+ #include <ATen/ops/atleast_1d_compositeimplicitautograd_dispatch.h>
126
+ #include <ATen/ops/atleast_2d_compositeimplicitautograd_dispatch.h>
127
+ #include <ATen/ops/atleast_3d_compositeimplicitautograd_dispatch.h>
128
+ #include <ATen/ops/avg_pool1d_compositeimplicitautograd_dispatch.h>
129
+ #include <ATen/ops/batch_norm_compositeimplicitautograd_dispatch.h>
130
+ #include <ATen/ops/bilinear_compositeimplicitautograd_dispatch.h>
131
+ #include <ATen/ops/broadcast_tensors_compositeimplicitautograd_dispatch.h>
132
+ #include <ATen/ops/broadcast_to_compositeimplicitautograd_dispatch.h>
133
+ #include <ATen/ops/can_cast_compositeimplicitautograd_dispatch.h>
134
+ #include <ATen/ops/cartesian_prod_compositeimplicitautograd_dispatch.h>
135
+ #include <ATen/ops/cat_compositeimplicitautograd_dispatch.h>
136
+ #include <ATen/ops/cdist_compositeimplicitautograd_dispatch.h>
137
+ #include <ATen/ops/chain_matmul_compositeimplicitautograd_dispatch.h>
138
+ #include <ATen/ops/chalf_compositeimplicitautograd_dispatch.h>
139
+ #include <ATen/ops/choose_qparams_optimized_compositeimplicitautograd_dispatch.h>
140
+ #include <ATen/ops/chunk_compositeimplicitautograd_dispatch.h>
141
+ #include <ATen/ops/clip_compositeimplicitautograd_dispatch.h>
142
+ #include <ATen/ops/coalesce_compositeimplicitautograd_dispatch.h>
143
+ #include <ATen/ops/column_stack_compositeimplicitautograd_dispatch.h>
144
+ #include <ATen/ops/combinations_compositeimplicitautograd_dispatch.h>
145
+ #include <ATen/ops/concat_compositeimplicitautograd_dispatch.h>
146
+ #include <ATen/ops/concatenate_compositeimplicitautograd_dispatch.h>
147
+ #include <ATen/ops/conj_compositeimplicitautograd_dispatch.h>
148
+ #include <ATen/ops/conj_physical_compositeimplicitautograd_dispatch.h>
149
+ #include <ATen/ops/contiguous_compositeimplicitautograd_dispatch.h>
150
+ #include <ATen/ops/conv1d_compositeimplicitautograd_dispatch.h>
151
+ #include <ATen/ops/conv2d_compositeimplicitautograd_dispatch.h>
152
+ #include <ATen/ops/conv3d_compositeimplicitautograd_dispatch.h>
153
+ #include <ATen/ops/conv_tbc_backward_compositeimplicitautograd_dispatch.h>
154
+ #include <ATen/ops/conv_transpose1d_compositeimplicitautograd_dispatch.h>
155
+ #include <ATen/ops/conv_transpose2d_compositeimplicitautograd_dispatch.h>
156
+ #include <ATen/ops/conv_transpose3d_compositeimplicitautograd_dispatch.h>
157
+ #include <ATen/ops/corrcoef_compositeimplicitautograd_dispatch.h>
158
+ #include <ATen/ops/cosine_embedding_loss_compositeimplicitautograd_dispatch.h>
159
+ #include <ATen/ops/cosine_similarity_compositeimplicitautograd_dispatch.h>
160
+ #include <ATen/ops/cov_compositeimplicitautograd_dispatch.h>
161
+ #include <ATen/ops/cross_compositeimplicitautograd_dispatch.h>
162
+ #include <ATen/ops/cross_entropy_loss_compositeimplicitautograd_dispatch.h>
163
+ #include <ATen/ops/ctc_loss_compositeimplicitautograd_dispatch.h>
164
+ #include <ATen/ops/cudnn_is_acceptable_compositeimplicitautograd_dispatch.h>
165
+ #include <ATen/ops/cummax_compositeimplicitautograd_dispatch.h>
166
+ #include <ATen/ops/cummaxmin_backward_compositeimplicitautograd_dispatch.h>
167
+ #include <ATen/ops/cummin_compositeimplicitautograd_dispatch.h>
168
+ #include <ATen/ops/cumprod_compositeimplicitautograd_dispatch.h>
169
+ #include <ATen/ops/cumprod_backward_compositeimplicitautograd_dispatch.h>
170
+ #include <ATen/ops/cumsum_compositeimplicitautograd_dispatch.h>
171
+ #include <ATen/ops/cumulative_trapezoid_compositeimplicitautograd_dispatch.h>
172
+ #include <ATen/ops/data_compositeimplicitautograd_dispatch.h>
173
+ #include <ATen/ops/det_compositeimplicitautograd_dispatch.h>
174
+ #include <ATen/ops/diag_compositeimplicitautograd_dispatch.h>
175
+ #include <ATen/ops/diagflat_compositeimplicitautograd_dispatch.h>
176
+ #include <ATen/ops/diagonal_compositeimplicitautograd_dispatch.h>
177
+ #include <ATen/ops/diff_compositeimplicitautograd_dispatch.h>
178
+ #include <ATen/ops/divide_compositeimplicitautograd_dispatch.h>
179
+ #include <ATen/ops/dropout_compositeimplicitautograd_dispatch.h>
180
+ #include <ATen/ops/dsplit_compositeimplicitautograd_dispatch.h>
181
+ #include <ATen/ops/dstack_compositeimplicitautograd_dispatch.h>
182
+ #include <ATen/ops/einsum_compositeimplicitautograd_dispatch.h>
183
+ #include <ATen/ops/embedding_backward_compositeimplicitautograd_dispatch.h>
184
+ #include <ATen/ops/embedding_bag_compositeimplicitautograd_dispatch.h>
185
+ #include <ATen/ops/embedding_sparse_backward_compositeimplicitautograd_dispatch.h>
186
+ #include <ATen/ops/empty_compositeimplicitautograd_dispatch.h>
187
+ #include <ATen/ops/expand_as_compositeimplicitautograd_dispatch.h>
188
+ #include <ATen/ops/fake_quantize_per_channel_affine_compositeimplicitautograd_dispatch.h>
189
+ #include <ATen/ops/fake_quantize_per_channel_affine_cachemask_backward_compositeimplicitautograd_dispatch.h>
190
+ #include <ATen/ops/fake_quantize_per_tensor_affine_compositeimplicitautograd_dispatch.h>
191
+ #include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_compositeimplicitautograd_dispatch.h>
192
+ #include <ATen/ops/fbgemm_linear_fp16_weight_compositeimplicitautograd_dispatch.h>
193
+ #include <ATen/ops/fbgemm_linear_fp16_weight_fp32_activation_compositeimplicitautograd_dispatch.h>
194
+ #include <ATen/ops/fbgemm_linear_int8_weight_compositeimplicitautograd_dispatch.h>
195
+ #include <ATen/ops/fbgemm_linear_int8_weight_fp32_activation_compositeimplicitautograd_dispatch.h>
196
+ #include <ATen/ops/fbgemm_linear_quantize_weight_compositeimplicitautograd_dispatch.h>
197
+ #include <ATen/ops/fbgemm_pack_gemm_matrix_fp16_compositeimplicitautograd_dispatch.h>
198
+ #include <ATen/ops/fbgemm_pack_quantized_matrix_compositeimplicitautograd_dispatch.h>
199
+ #include <ATen/ops/feature_alpha_dropout_compositeimplicitautograd_dispatch.h>
200
+ #include <ATen/ops/feature_dropout_compositeimplicitautograd_dispatch.h>
201
+ #include <ATen/ops/fft_fft_compositeimplicitautograd_dispatch.h>
202
+ #include <ATen/ops/fft_fft2_compositeimplicitautograd_dispatch.h>
203
+ #include <ATen/ops/fft_fftn_compositeimplicitautograd_dispatch.h>
204
+ #include <ATen/ops/fft_fftshift_compositeimplicitautograd_dispatch.h>
205
+ #include <ATen/ops/fft_hfft_compositeimplicitautograd_dispatch.h>
206
+ #include <ATen/ops/fft_hfft2_compositeimplicitautograd_dispatch.h>
207
+ #include <ATen/ops/fft_hfftn_compositeimplicitautograd_dispatch.h>
208
+ #include <ATen/ops/fft_ifft_compositeimplicitautograd_dispatch.h>
209
+ #include <ATen/ops/fft_ifft2_compositeimplicitautograd_dispatch.h>
210
+ #include <ATen/ops/fft_ifftn_compositeimplicitautograd_dispatch.h>
211
+ #include <ATen/ops/fft_ifftshift_compositeimplicitautograd_dispatch.h>
212
+ #include <ATen/ops/fft_ihfft_compositeimplicitautograd_dispatch.h>
213
+ #include <ATen/ops/fft_ihfft2_compositeimplicitautograd_dispatch.h>
214
+ #include <ATen/ops/fft_ihfftn_compositeimplicitautograd_dispatch.h>
215
+ #include <ATen/ops/fft_irfft_compositeimplicitautograd_dispatch.h>
216
+ #include <ATen/ops/fft_irfft2_compositeimplicitautograd_dispatch.h>
217
+ #include <ATen/ops/fft_irfftn_compositeimplicitautograd_dispatch.h>
218
+ #include <ATen/ops/fft_rfft_compositeimplicitautograd_dispatch.h>
219
+ #include <ATen/ops/fft_rfft2_compositeimplicitautograd_dispatch.h>
220
+ #include <ATen/ops/fft_rfftn_compositeimplicitautograd_dispatch.h>
221
+ #include <ATen/ops/fill_diagonal_compositeimplicitautograd_dispatch.h>
222
+ #include <ATen/ops/fix_compositeimplicitautograd_dispatch.h>
223
+ #include <ATen/ops/flatten_compositeimplicitautograd_dispatch.h>
224
+ #include <ATen/ops/flatten_dense_tensors_compositeimplicitautograd_dispatch.h>
225
+ #include <ATen/ops/fliplr_compositeimplicitautograd_dispatch.h>
226
+ #include <ATen/ops/flipud_compositeimplicitautograd_dispatch.h>
227
+ #include <ATen/ops/float_power_compositeimplicitautograd_dispatch.h>
228
+ #include <ATen/ops/frobenius_norm_compositeimplicitautograd_dispatch.h>
229
+ #include <ATen/ops/fused_moving_avg_obs_fake_quant_compositeimplicitautograd_dispatch.h>
230
+ #include <ATen/ops/gather_compositeimplicitautograd_dispatch.h>
231
+ #include <ATen/ops/gather_backward_compositeimplicitautograd_dispatch.h>
232
+ #include <ATen/ops/ger_compositeimplicitautograd_dispatch.h>
233
+ #include <ATen/ops/gradient_compositeimplicitautograd_dispatch.h>
234
+ #include <ATen/ops/greater_compositeimplicitautograd_dispatch.h>
235
+ #include <ATen/ops/greater_equal_compositeimplicitautograd_dispatch.h>
236
+ #include <ATen/ops/grid_sampler_compositeimplicitautograd_dispatch.h>
237
+ #include <ATen/ops/group_norm_compositeimplicitautograd_dispatch.h>
238
+ #include <ATen/ops/gru_compositeimplicitautograd_dispatch.h>
239
+ #include <ATen/ops/gru_cell_compositeimplicitautograd_dispatch.h>
240
+ #include <ATen/ops/hinge_embedding_loss_compositeimplicitautograd_dispatch.h>
241
+ #include <ATen/ops/histogramdd_compositeimplicitautograd_dispatch.h>
242
+ #include <ATen/ops/hsplit_compositeimplicitautograd_dispatch.h>
243
+ #include <ATen/ops/hstack_compositeimplicitautograd_dispatch.h>
244
+ #include <ATen/ops/imag_compositeimplicitautograd_dispatch.h>
245
+ #include <ATen/ops/index_add_compositeimplicitautograd_dispatch.h>
246
+ #include <ATen/ops/index_copy_compositeimplicitautograd_dispatch.h>
247
+ #include <ATen/ops/index_fill_compositeimplicitautograd_dispatch.h>
248
+ #include <ATen/ops/index_select_compositeimplicitautograd_dispatch.h>
249
+ #include <ATen/ops/index_select_backward_compositeimplicitautograd_dispatch.h>
250
+ #include <ATen/ops/infinitely_differentiable_gelu_backward_compositeimplicitautograd_dispatch.h>
251
+ #include <ATen/ops/inner_compositeimplicitautograd_dispatch.h>
252
+ #include <ATen/ops/instance_norm_compositeimplicitautograd_dispatch.h>
253
+ #include <ATen/ops/inverse_compositeimplicitautograd_dispatch.h>
254
+ #include <ATen/ops/is_complex_compositeimplicitautograd_dispatch.h>
255
+ #include <ATen/ops/is_conj_compositeimplicitautograd_dispatch.h>
256
+ #include <ATen/ops/is_distributed_compositeimplicitautograd_dispatch.h>
257
+ #include <ATen/ops/is_floating_point_compositeimplicitautograd_dispatch.h>
258
+ #include <ATen/ops/is_inference_compositeimplicitautograd_dispatch.h>
259
+ #include <ATen/ops/is_leaf_compositeimplicitautograd_dispatch.h>
260
+ #include <ATen/ops/is_neg_compositeimplicitautograd_dispatch.h>
261
+ #include <ATen/ops/is_nonzero_compositeimplicitautograd_dispatch.h>
262
+ #include <ATen/ops/is_signed_compositeimplicitautograd_dispatch.h>
263
+ #include <ATen/ops/is_vulkan_available_compositeimplicitautograd_dispatch.h>
264
+ #include <ATen/ops/isclose_compositeimplicitautograd_dispatch.h>
265
+ #include <ATen/ops/isfinite_compositeimplicitautograd_dispatch.h>
266
+ #include <ATen/ops/isreal_compositeimplicitautograd_dispatch.h>
267
+ #include <ATen/ops/istft_compositeimplicitautograd_dispatch.h>
268
+ #include <ATen/ops/item_compositeimplicitautograd_dispatch.h>
269
+ #include <ATen/ops/kl_div_compositeimplicitautograd_dispatch.h>
270
+ #include <ATen/ops/kron_compositeimplicitautograd_dispatch.h>
271
+ #include <ATen/ops/kthvalue_compositeimplicitautograd_dispatch.h>
272
+ #include <ATen/ops/l1_loss_compositeimplicitautograd_dispatch.h>
273
+ #include <ATen/ops/layer_norm_compositeimplicitautograd_dispatch.h>
274
+ #include <ATen/ops/ldexp_compositeimplicitautograd_dispatch.h>
275
+ #include <ATen/ops/less_compositeimplicitautograd_dispatch.h>
276
+ #include <ATen/ops/less_equal_compositeimplicitautograd_dispatch.h>
277
+ #include <ATen/ops/linalg_cholesky_compositeimplicitautograd_dispatch.h>
278
+ #include <ATen/ops/linalg_cond_compositeimplicitautograd_dispatch.h>
279
+ #include <ATen/ops/linalg_det_compositeimplicitautograd_dispatch.h>
280
+ #include <ATen/ops/linalg_diagonal_compositeimplicitautograd_dispatch.h>
281
+ #include <ATen/ops/linalg_eigh_compositeimplicitautograd_dispatch.h>
282
+ #include <ATen/ops/linalg_eigvals_compositeimplicitautograd_dispatch.h>
283
+ #include <ATen/ops/linalg_eigvalsh_compositeimplicitautograd_dispatch.h>
284
+ #include <ATen/ops/linalg_inv_compositeimplicitautograd_dispatch.h>
285
+ #include <ATen/ops/linalg_ldl_factor_compositeimplicitautograd_dispatch.h>
286
+ #include <ATen/ops/linalg_lu_factor_compositeimplicitautograd_dispatch.h>
287
+ #include <ATen/ops/linalg_matmul_compositeimplicitautograd_dispatch.h>
288
+ #include <ATen/ops/linalg_matrix_norm_compositeimplicitautograd_dispatch.h>
289
+ #include <ATen/ops/linalg_matrix_power_compositeimplicitautograd_dispatch.h>
290
+ #include <ATen/ops/linalg_matrix_rank_compositeimplicitautograd_dispatch.h>
291
+ #include <ATen/ops/linalg_multi_dot_compositeimplicitautograd_dispatch.h>
292
+ #include <ATen/ops/linalg_norm_compositeimplicitautograd_dispatch.h>
293
+ #include <ATen/ops/linalg_pinv_compositeimplicitautograd_dispatch.h>
294
+ #include <ATen/ops/linalg_slogdet_compositeimplicitautograd_dispatch.h>
295
+ #include <ATen/ops/linalg_solve_compositeimplicitautograd_dispatch.h>
296
+ #include <ATen/ops/linalg_solve_ex_compositeimplicitautograd_dispatch.h>
297
+ #include <ATen/ops/linalg_svd_compositeimplicitautograd_dispatch.h>
298
+ #include <ATen/ops/linalg_svdvals_compositeimplicitautograd_dispatch.h>
299
+ #include <ATen/ops/linalg_tensorinv_compositeimplicitautograd_dispatch.h>
300
+ #include <ATen/ops/linalg_tensorsolve_compositeimplicitautograd_dispatch.h>
301
+ #include <ATen/ops/linalg_vander_compositeimplicitautograd_dispatch.h>
302
+ #include <ATen/ops/linalg_vecdot_compositeimplicitautograd_dispatch.h>
303
+ #include <ATen/ops/linear_compositeimplicitautograd_dispatch.h>
304
+ #include <ATen/ops/log_sigmoid_compositeimplicitautograd_dispatch.h>
305
+ #include <ATen/ops/log_softmax_compositeimplicitautograd_dispatch.h>
306
+ #include <ATen/ops/logcumsumexp_compositeimplicitautograd_dispatch.h>
307
+ #include <ATen/ops/logdet_compositeimplicitautograd_dispatch.h>
308
+ #include <ATen/ops/logsumexp_compositeimplicitautograd_dispatch.h>
309
+ #include <ATen/ops/lstm_compositeimplicitautograd_dispatch.h>
310
+ #include <ATen/ops/lstm_cell_compositeimplicitautograd_dispatch.h>
311
+ #include <ATen/ops/lu_solve_compositeimplicitautograd_dispatch.h>
312
+ #include <ATen/ops/mH_compositeimplicitautograd_dispatch.h>
313
+ #include <ATen/ops/mT_compositeimplicitautograd_dispatch.h>
314
+ #include <ATen/ops/margin_ranking_loss_compositeimplicitautograd_dispatch.h>
315
+ #include <ATen/ops/masked_select_backward_compositeimplicitautograd_dispatch.h>
316
+ #include <ATen/ops/matmul_compositeimplicitautograd_dispatch.h>
317
+ #include <ATen/ops/matrix_H_compositeimplicitautograd_dispatch.h>
318
+ #include <ATen/ops/matrix_exp_compositeimplicitautograd_dispatch.h>
319
+ #include <ATen/ops/matrix_exp_backward_compositeimplicitautograd_dispatch.h>
320
+ #include <ATen/ops/matrix_power_compositeimplicitautograd_dispatch.h>
321
+ #include <ATen/ops/max_compositeimplicitautograd_dispatch.h>
322
+ #include <ATen/ops/max_pool1d_compositeimplicitautograd_dispatch.h>
323
+ #include <ATen/ops/max_pool1d_with_indices_compositeimplicitautograd_dispatch.h>
324
+ #include <ATen/ops/max_pool2d_compositeimplicitautograd_dispatch.h>
325
+ #include <ATen/ops/max_pool3d_compositeimplicitautograd_dispatch.h>
326
+ #include <ATen/ops/mean_compositeimplicitautograd_dispatch.h>
327
+ #include <ATen/ops/median_compositeimplicitautograd_dispatch.h>
328
+ #include <ATen/ops/meshgrid_compositeimplicitautograd_dispatch.h>
329
+ #include <ATen/ops/min_compositeimplicitautograd_dispatch.h>
330
+ #include <ATen/ops/mish_backward_compositeimplicitautograd_dispatch.h>
331
+ #include <ATen/ops/mode_compositeimplicitautograd_dispatch.h>
332
+ #include <ATen/ops/moveaxis_compositeimplicitautograd_dispatch.h>
333
+ #include <ATen/ops/movedim_compositeimplicitautograd_dispatch.h>
334
+ #include <ATen/ops/msort_compositeimplicitautograd_dispatch.h>
335
+ #include <ATen/ops/multilabel_margin_loss_compositeimplicitautograd_dispatch.h>
336
+ #include <ATen/ops/multiply_compositeimplicitautograd_dispatch.h>
337
+ #include <ATen/ops/nanmean_compositeimplicitautograd_dispatch.h>
338
+ #include <ATen/ops/nanmedian_compositeimplicitautograd_dispatch.h>
339
+ #include <ATen/ops/nanquantile_compositeimplicitautograd_dispatch.h>
340
+ #include <ATen/ops/narrow_compositeimplicitautograd_dispatch.h>
341
+ #include <ATen/ops/native_channel_shuffle_compositeimplicitautograd_dispatch.h>
342
+ #include <ATen/ops/negative_compositeimplicitautograd_dispatch.h>
343
+ #include <ATen/ops/nested_to_padded_tensor_compositeimplicitautograd_dispatch.h>
344
+ #include <ATen/ops/nll_loss_compositeimplicitautograd_dispatch.h>
345
+ #include <ATen/ops/nll_loss2d_compositeimplicitautograd_dispatch.h>
346
+ #include <ATen/ops/nll_loss_nd_compositeimplicitautograd_dispatch.h>
347
+ #include <ATen/ops/nonzero_numpy_compositeimplicitautograd_dispatch.h>
348
+ #include <ATen/ops/norm_compositeimplicitautograd_dispatch.h>
349
+ #include <ATen/ops/norm_except_dim_compositeimplicitautograd_dispatch.h>
350
+ #include <ATen/ops/not_equal_compositeimplicitautograd_dispatch.h>
351
+ #include <ATen/ops/nuclear_norm_compositeimplicitautograd_dispatch.h>
352
+ #include <ATen/ops/numpy_T_compositeimplicitautograd_dispatch.h>
353
+ #include <ATen/ops/one_hot_compositeimplicitautograd_dispatch.h>
354
+ #include <ATen/ops/or_compositeimplicitautograd_dispatch.h>
355
+ #include <ATen/ops/orgqr_compositeimplicitautograd_dispatch.h>
356
+ #include <ATen/ops/outer_compositeimplicitautograd_dispatch.h>
357
+ #include <ATen/ops/output_nr_compositeimplicitautograd_dispatch.h>
358
+ #include <ATen/ops/pad_compositeimplicitautograd_dispatch.h>
359
+ #include <ATen/ops/pad_sequence_compositeimplicitautograd_dispatch.h>
360
+ #include <ATen/ops/pairwise_distance_compositeimplicitautograd_dispatch.h>
361
+ #include <ATen/ops/pdist_compositeimplicitautograd_dispatch.h>
362
+ #include <ATen/ops/pin_memory_compositeimplicitautograd_dispatch.h>
363
+ #include <ATen/ops/pinverse_compositeimplicitautograd_dispatch.h>
364
+ #include <ATen/ops/poisson_nll_loss_compositeimplicitautograd_dispatch.h>
365
+ #include <ATen/ops/positive_compositeimplicitautograd_dispatch.h>
366
+ #include <ATen/ops/prelu_compositeimplicitautograd_dispatch.h>
367
+ #include <ATen/ops/prod_compositeimplicitautograd_dispatch.h>
368
+ #include <ATen/ops/promote_types_compositeimplicitautograd_dispatch.h>
369
+ #include <ATen/ops/qr_compositeimplicitautograd_dispatch.h>
370
+ #include <ATen/ops/quantile_compositeimplicitautograd_dispatch.h>
371
+ #include <ATen/ops/quantized_gru_cell_compositeimplicitautograd_dispatch.h>
372
+ #include <ATen/ops/quantized_lstm_cell_compositeimplicitautograd_dispatch.h>
373
+ #include <ATen/ops/quantized_rnn_relu_cell_compositeimplicitautograd_dispatch.h>
374
+ #include <ATen/ops/quantized_rnn_tanh_cell_compositeimplicitautograd_dispatch.h>
375
+ #include <ATen/ops/rand_compositeimplicitautograd_dispatch.h>
376
+ #include <ATen/ops/randn_compositeimplicitautograd_dispatch.h>
377
+ #include <ATen/ops/ravel_compositeimplicitautograd_dispatch.h>
378
+ #include <ATen/ops/real_compositeimplicitautograd_dispatch.h>
379
+ #include <ATen/ops/refine_names_compositeimplicitautograd_dispatch.h>
380
+ #include <ATen/ops/relu6_compositeimplicitautograd_dispatch.h>
381
+ #include <ATen/ops/rename_compositeimplicitautograd_dispatch.h>
382
+ #include <ATen/ops/repeat_interleave_compositeimplicitautograd_dispatch.h>
383
+ #include <ATen/ops/requires_grad_compositeimplicitautograd_dispatch.h>
384
+ #include <ATen/ops/reshape_compositeimplicitautograd_dispatch.h>
385
+ #include <ATen/ops/reshape_as_compositeimplicitautograd_dispatch.h>
386
+ #include <ATen/ops/resolve_conj_compositeimplicitautograd_dispatch.h>
387
+ #include <ATen/ops/resolve_neg_compositeimplicitautograd_dispatch.h>
388
+ #include <ATen/ops/result_type_compositeimplicitautograd_dispatch.h>
389
+ #include <ATen/ops/retain_grad_compositeimplicitautograd_dispatch.h>
390
+ #include <ATen/ops/retains_grad_compositeimplicitautograd_dispatch.h>
391
+ #include <ATen/ops/rnn_relu_compositeimplicitautograd_dispatch.h>
392
+ #include <ATen/ops/rnn_relu_cell_compositeimplicitautograd_dispatch.h>
393
+ #include <ATen/ops/rnn_tanh_compositeimplicitautograd_dispatch.h>
394
+ #include <ATen/ops/rnn_tanh_cell_compositeimplicitautograd_dispatch.h>
395
+ #include <ATen/ops/row_stack_compositeimplicitautograd_dispatch.h>
396
+ #include <ATen/ops/rrelu_compositeimplicitautograd_dispatch.h>
397
+ #include <ATen/ops/scaled_dot_product_attention_compositeimplicitautograd_dispatch.h>
398
+ #include <ATen/ops/scatter_compositeimplicitautograd_dispatch.h>
399
+ #include <ATen/ops/scatter_add_compositeimplicitautograd_dispatch.h>
400
+ #include <ATen/ops/select_compositeimplicitautograd_dispatch.h>
401
+ #include <ATen/ops/selu_compositeimplicitautograd_dispatch.h>
402
+ #include <ATen/ops/set_compositeimplicitautograd_dispatch.h>
403
+ #include <ATen/ops/set_data_compositeimplicitautograd_dispatch.h>
404
+ #include <ATen/ops/silu_backward_compositeimplicitautograd_dispatch.h>
405
+ #include <ATen/ops/size_compositeimplicitautograd_dispatch.h>
406
+ #include <ATen/ops/slogdet_compositeimplicitautograd_dispatch.h>
407
+ #include <ATen/ops/slow_conv3d_compositeimplicitautograd_dispatch.h>
408
+ #include <ATen/ops/smm_compositeimplicitautograd_dispatch.h>
409
+ #include <ATen/ops/softmax_compositeimplicitautograd_dispatch.h>
410
+ #include <ATen/ops/sort_compositeimplicitautograd_dispatch.h>
411
+ #include <ATen/ops/sparse_bsc_tensor_compositeimplicitautograd_dispatch.h>
412
+ #include <ATen/ops/sparse_bsr_tensor_compositeimplicitautograd_dispatch.h>
413
+ #include <ATen/ops/sparse_coo_tensor_compositeimplicitautograd_dispatch.h>
414
+ #include <ATen/ops/sparse_csc_tensor_compositeimplicitautograd_dispatch.h>
415
+ #include <ATen/ops/sparse_csr_tensor_compositeimplicitautograd_dispatch.h>
416
+ #include <ATen/ops/special_digamma_compositeimplicitautograd_dispatch.h>
417
+ #include <ATen/ops/special_erf_compositeimplicitautograd_dispatch.h>
418
+ #include <ATen/ops/special_erfc_compositeimplicitautograd_dispatch.h>
419
+ #include <ATen/ops/special_erfinv_compositeimplicitautograd_dispatch.h>
420
+ #include <ATen/ops/special_exp2_compositeimplicitautograd_dispatch.h>
421
+ #include <ATen/ops/special_expit_compositeimplicitautograd_dispatch.h>
422
+ #include <ATen/ops/special_expm1_compositeimplicitautograd_dispatch.h>
423
+ #include <ATen/ops/special_gammainc_compositeimplicitautograd_dispatch.h>
424
+ #include <ATen/ops/special_gammaincc_compositeimplicitautograd_dispatch.h>
425
+ #include <ATen/ops/special_gammaln_compositeimplicitautograd_dispatch.h>
426
+ #include <ATen/ops/special_i0_compositeimplicitautograd_dispatch.h>
427
+ #include <ATen/ops/special_log1p_compositeimplicitautograd_dispatch.h>
428
+ #include <ATen/ops/special_log_softmax_compositeimplicitautograd_dispatch.h>
429
+ #include <ATen/ops/special_logit_compositeimplicitautograd_dispatch.h>
430
+ #include <ATen/ops/special_logsumexp_compositeimplicitautograd_dispatch.h>
431
+ #include <ATen/ops/special_multigammaln_compositeimplicitautograd_dispatch.h>
432
+ #include <ATen/ops/special_ndtr_compositeimplicitautograd_dispatch.h>
433
+ #include <ATen/ops/special_polygamma_compositeimplicitautograd_dispatch.h>
434
+ #include <ATen/ops/special_psi_compositeimplicitautograd_dispatch.h>
435
+ #include <ATen/ops/special_round_compositeimplicitautograd_dispatch.h>
436
+ #include <ATen/ops/special_sinc_compositeimplicitautograd_dispatch.h>
437
+ #include <ATen/ops/special_softmax_compositeimplicitautograd_dispatch.h>
438
+ #include <ATen/ops/special_xlogy_compositeimplicitautograd_dispatch.h>
439
+ #include <ATen/ops/split_compositeimplicitautograd_dispatch.h>
440
+ #include <ATen/ops/square_compositeimplicitautograd_dispatch.h>
441
+ #include <ATen/ops/squeeze_compositeimplicitautograd_dispatch.h>
442
+ #include <ATen/ops/sspaddmm_compositeimplicitautograd_dispatch.h>
443
+ #include <ATen/ops/std_compositeimplicitautograd_dispatch.h>
444
+ #include <ATen/ops/std_mean_compositeimplicitautograd_dispatch.h>
445
+ #include <ATen/ops/stft_compositeimplicitautograd_dispatch.h>
446
+ #include <ATen/ops/stride_compositeimplicitautograd_dispatch.h>
447
+ #include <ATen/ops/subtract_compositeimplicitautograd_dispatch.h>
448
+ #include <ATen/ops/sum_compositeimplicitautograd_dispatch.h>
449
+ #include <ATen/ops/sum_to_size_compositeimplicitautograd_dispatch.h>
450
+ #include <ATen/ops/svd_compositeimplicitautograd_dispatch.h>
451
+ #include <ATen/ops/swapaxes_compositeimplicitautograd_dispatch.h>
452
+ #include <ATen/ops/swapdims_compositeimplicitautograd_dispatch.h>
453
+ #include <ATen/ops/sym_numel_compositeimplicitautograd_dispatch.h>
454
+ #include <ATen/ops/sym_size_compositeimplicitautograd_dispatch.h>
455
+ #include <ATen/ops/sym_storage_offset_compositeimplicitautograd_dispatch.h>
456
+ #include <ATen/ops/sym_stride_compositeimplicitautograd_dispatch.h>
457
+ #include <ATen/ops/take_along_dim_compositeimplicitautograd_dispatch.h>
458
+ #include <ATen/ops/tensor_split_compositeimplicitautograd_dispatch.h>
459
+ #include <ATen/ops/tensordot_compositeimplicitautograd_dispatch.h>
460
+ #include <ATen/ops/thnn_conv2d_compositeimplicitautograd_dispatch.h>
461
+ #include <ATen/ops/tile_compositeimplicitautograd_dispatch.h>
462
+ #include <ATen/ops/to_compositeimplicitautograd_dispatch.h>
463
+ #include <ATen/ops/to_dense_compositeimplicitautograd_dispatch.h>
464
+ #include <ATen/ops/to_dense_backward_compositeimplicitautograd_dispatch.h>
465
+ #include <ATen/ops/to_mkldnn_backward_compositeimplicitautograd_dispatch.h>
466
+ #include <ATen/ops/to_sparse_compositeimplicitautograd_dispatch.h>
467
+ #include <ATen/ops/to_sparse_bsc_compositeimplicitautograd_dispatch.h>
468
+ #include <ATen/ops/to_sparse_bsr_compositeimplicitautograd_dispatch.h>
469
+ #include <ATen/ops/to_sparse_csc_compositeimplicitautograd_dispatch.h>
470
+ #include <ATen/ops/to_sparse_csr_compositeimplicitautograd_dispatch.h>
471
+ #include <ATen/ops/trace_backward_compositeimplicitautograd_dispatch.h>
472
+ #include <ATen/ops/transpose_compositeimplicitautograd_dispatch.h>
473
+ #include <ATen/ops/trapezoid_compositeimplicitautograd_dispatch.h>
474
+ #include <ATen/ops/trapz_compositeimplicitautograd_dispatch.h>
475
+ #include <ATen/ops/triplet_margin_loss_compositeimplicitautograd_dispatch.h>
476
+ #include <ATen/ops/true_divide_compositeimplicitautograd_dispatch.h>
477
+ #include <ATen/ops/type_as_compositeimplicitautograd_dispatch.h>
478
+ #include <ATen/ops/unbind_compositeimplicitautograd_dispatch.h>
479
+ #include <ATen/ops/unflatten_compositeimplicitautograd_dispatch.h>
480
+ #include <ATen/ops/unflatten_dense_tensors_compositeimplicitautograd_dispatch.h>
481
+ #include <ATen/ops/unsafe_chunk_compositeimplicitautograd_dispatch.h>
482
+ #include <ATen/ops/upsample_bicubic2d_compositeimplicitautograd_dispatch.h>
483
+ #include <ATen/ops/upsample_bilinear2d_compositeimplicitautograd_dispatch.h>
484
+ #include <ATen/ops/upsample_linear1d_compositeimplicitautograd_dispatch.h>
485
+ #include <ATen/ops/upsample_nearest1d_compositeimplicitautograd_dispatch.h>
486
+ #include <ATen/ops/upsample_nearest2d_compositeimplicitautograd_dispatch.h>
487
+ #include <ATen/ops/upsample_nearest3d_compositeimplicitautograd_dispatch.h>
488
+ #include <ATen/ops/upsample_trilinear3d_compositeimplicitautograd_dispatch.h>
489
+ #include <ATen/ops/value_selecting_reduction_backward_compositeimplicitautograd_dispatch.h>
490
+ #include <ATen/ops/vander_compositeimplicitautograd_dispatch.h>
491
+ #include <ATen/ops/var_compositeimplicitautograd_dispatch.h>
492
+ #include <ATen/ops/var_mean_compositeimplicitautograd_dispatch.h>
493
+ #include <ATen/ops/view_as_compositeimplicitautograd_dispatch.h>
494
+ #include <ATen/ops/vsplit_compositeimplicitautograd_dispatch.h>
495
+ #include <ATen/ops/vstack_compositeimplicitautograd_dispatch.h>
496
+ #include <ATen/ops/where_compositeimplicitautograd_dispatch.h>
497
+ #include <ATen/ops/xor_compositeimplicitautograd_dispatch.h>
498
+
499
+
500
+
videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradNestedTensorFunctions.h ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #include <ATen/core/TensorBody.h>
2
+
3
+ // TODO Undo all logic introduced for Note [Avoiding Include Cycles In Static Dispatch]
4
+ // Code introduced to avoid cyclic dependency in static dispatch is no longer
5
+ // needed as static dispatch logic is moved from TensorBody.h, which caused cycles in the first place,
6
+ // to Operators.cpp for supporting multiple backends with multiple kernels.
7
+ //
8
+ // Note [Avoiding Include Cycles In Static Dispatch]
9
+ // In order to avoid #include cycles in the static dispatch build, we've carefully split out
10
+ // the static function definition files into {DispatchKey}Functions.h and {DispatchKey}Functions_inl.h.
11
+ //
12
+ // Without this split, the include cycle looks like TensorBody.h -> CPUFunctions.h -> TensorBody.h.
13
+ // - TensorBody.h #includes CPUFunctions.h in the static dispatch build, because the tensor methods
14
+ // all need to call into the fastpath C++ API defined in CPUFunctions.h. The methods are also all
15
+ // directly inlined into TensorBody.h.
16
+ // - CPUFunctions.h #includes TensorBody.h because it contains function declarations for the entire C++ API,
17
+ // which include functions that have defaultable optional<Tensor> arguments.
18
+ // That requires knowing the full Tensor class definition.
19
+ //
20
+ // We break the cycle by doing the following:
21
+ // - Split out CPUFunction.h into two files: CPUFunctions.h and CPUFunctions_inl.h
22
+ // - CPUFunction.h is a dummy file that just includes the Tensor class and includes CPUFunctions_inl.,
23
+ // - CPUFunctions_inl.h includes everything else
24
+ // - (only in the static dispatch build) TensorBody.h makes sure to finish defining the Tensor class,
25
+ // and then it includes CPUFunctions_inl.h.
26
+ // - All other files that want the cpu fastpath functions can include CPUFunctions.h directly.
27
+ // - This also means that static dispatch build, CPUFunctions.h only needs to
28
+ // #include TensorBody.h, and it will automatically bring in CPUFunctions_inl.h.
29
+ #include <ATen/CompositeImplicitAutogradNestedTensorFunctions_inl.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/CompositeImplicitAutogradNestedTensorFunctions_inl.h ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunctions_inl.h
3
+
4
+ // NB: The implementing C++ file is RegisterDispatchKey.cpp
5
+
6
+ // The only #includes we need are for custom classes that have defaults in the C++ API
7
+ #include <c10/core/MemoryFormat.h>
8
+ #include <c10/core/Scalar.h>
9
+ #include <ATen/core/Reduction.h>
10
+
11
+ #if defined(AT_PER_OPERATOR_HEADERS) && defined(TORCH_ASSERT_ONLY_METHOD_OPERATORS)
12
+ #error This change adds a dependency on all pytorch operators, meaning the \
13
+ file will need to be re-compiled every time an operator is changed or added. \
14
+ Consider including a specific operator from \
15
+ <ATen/ops/{my_operator}_compositeimplicitautogradnestedtensor_dispatch.h>. \
16
+ See NOTE [TORCH_ASSERT_ONLY_METHOD_OPERATORS].
17
+ #endif
18
+
19
+ #include <ATen/ops/randn_like_compositeimplicitautogradnestedtensor_dispatch.h>
20
+ #include <ATen/ops/reshape_compositeimplicitautogradnestedtensor_dispatch.h>
21
+ #include <ATen/ops/reshape_as_compositeimplicitautogradnestedtensor_dispatch.h>
22
+ #include <ATen/ops/zeros_like_compositeimplicitautogradnestedtensor_dispatch.h>
23
+
24
+
25
+
videollama2/lib/python3.10/site-packages/torch/include/ATen/Config.h ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // Test these using #if AT_MKL_ENABLED(), not #ifdef, so that it's
4
+ // obvious if you forgot to include Config.h
5
+ // c.f. https://stackoverflow.com/questions/33759787/generating-an-error-if-checked-boolean-macro-is-not-defined
6
+ //
7
+ // DO NOT put the macros for CUDA libraries in this file; they belong in cuda/CUDAConfig.h
8
+
9
+ #define AT_MKLDNN_ENABLED() 1
10
+ #define AT_MKLDNN_ACL_ENABLED() 0
11
+ #define AT_MKL_ENABLED() 1
12
+ #define AT_MKL_SEQUENTIAL() 0
13
+ #define AT_POCKETFFT_ENABLED() 0
14
+ #define AT_NNPACK_ENABLED() 1
15
+ #define CAFFE2_STATIC_LINK_CUDA() 0
16
+ #define AT_BUILD_WITH_BLAS() 1
17
+ #define AT_BUILD_WITH_LAPACK() 1
18
+ #define AT_PARALLEL_OPENMP 1
19
+ #define AT_PARALLEL_NATIVE 0
20
+ #define AT_PARALLEL_NATIVE_TBB 0
21
+ #define AT_BLAS_F2C() 0
22
+ #define AT_BLAS_USE_CBLAS_DOT() 0
videollama2/lib/python3.10/site-packages/torch/include/ATen/Context.h ADDED
@@ -0,0 +1,518 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/CPUGeneratorImpl.h>
4
+ #include <ATen/LinalgBackend.h>
5
+ #include <ATen/core/ATenGeneral.h>
6
+ #include <ATen/core/DeprecatedTypeProperties.h>
7
+ #include <ATen/core/Generator.h>
8
+ #include <ATen/core/LegacyTypeDispatch.h>
9
+ #include <ATen/detail/CUDAHooksInterface.h>
10
+ #include <ATen/detail/HIPHooksInterface.h>
11
+ #include <ATen/detail/IPUHooksInterface.h>
12
+ #include <ATen/detail/MPSHooksInterface.h>
13
+ #include <ATen/detail/MTIAHooksInterface.h>
14
+ #include <ATen/detail/ORTHooksInterface.h>
15
+ #include <ATen/detail/PrivateUse1HooksInterface.h>
16
+ #include <ATen/detail/XPUHooksInterface.h>
17
+ #include <c10/core/QEngine.h>
18
+ #include <c10/core/impl/DeviceGuardImplInterface.h>
19
+ #include <c10/util/CallOnce.h>
20
+ #include <c10/util/Exception.h>
21
+ #include <c10/util/env.h>
22
+ #include <c10/util/irange.h>
23
+
24
+ #include <cstdint>
25
+ #include <memory>
26
+ #include <mutex>
27
+
28
+ namespace at {
29
+
30
+ class Tensor;
31
+
32
+ enum class TORCH_API Float32MatmulPrecision { HIGHEST, HIGH, MEDIUM };
33
+
34
+ class TORCH_API Context {
35
+ public:
36
+ Context();
37
+
38
+ const Generator& defaultGenerator(Device device) {
39
+ c10::DeviceType device_type = device.type();
40
+ initCUDAIfNeeded(device_type);
41
+ initHIPIfNeeded(device_type);
42
+ if (device_type == at::kCPU) {
43
+ return at::detail::getDefaultCPUGenerator();
44
+ } else if (device_type == at::kCUDA) {
45
+ return at::detail::getCUDAHooks().getDefaultCUDAGenerator(device.index());
46
+ } else if (device_type == at::kMPS) {
47
+ return at::detail::getMPSHooks().getDefaultMPSGenerator();
48
+ } else if (device_type == at::kXPU) {
49
+ return at::detail::getXPUHooks().getDefaultXPUGenerator(device.index());
50
+ } else if (device_type == at::kIPU) {
51
+ return at::detail::getIPUHooks().getDefaultIPUGenerator(device.index());
52
+ } else if (device_type == at::kPrivateUse1) {
53
+ return at::GetPrivateUse1HooksInterface()->getDefaultGenerator(
54
+ device.index());
55
+ } else {
56
+ AT_ERROR(c10::DeviceTypeName(device_type), " device type not enabled.");
57
+ }
58
+ }
59
+ Device getDeviceFromPtr(void* data, c10::DeviceType device_type) {
60
+ initCUDAIfNeeded(device_type);
61
+ initHIPIfNeeded(device_type);
62
+ if (device_type == at::kCPU) {
63
+ return c10::DeviceType::CPU;
64
+ } else if (device_type == at::kCUDA) {
65
+ return at::detail::getCUDAHooks().getDeviceFromPtr(data);
66
+ } else if (device_type == at::kPrivateUse1) {
67
+ return at::GetPrivateUse1HooksInterface()->getDeviceFromPtr(data);
68
+ } else {
69
+ AT_ERROR(c10::DeviceTypeName(device_type), " device type not enabled.");
70
+ }
71
+ }
72
+ static bool isPinnedPtr(const void* data) {
73
+ return detail::getCUDAHooks().isPinnedPtr(data);
74
+ }
75
+ static bool hasOpenMP();
76
+ static bool hasMKL();
77
+ static bool hasLAPACK();
78
+ static bool hasMKLDNN();
79
+ static bool hasMAGMA() {
80
+ return detail::getCUDAHooks().hasMAGMA();
81
+ }
82
+ static bool hasCUDA() {
83
+ return detail::getCUDAHooks().hasCUDA();
84
+ }
85
+ static bool hasMTIA() {
86
+ return detail::getMTIAHooks().hasMTIA();
87
+ }
88
+ static bool hasCUDART() {
89
+ return detail::getCUDAHooks().hasCUDART();
90
+ }
91
+ static long versionCUDART() {
92
+ return detail::getCUDAHooks().versionCUDART();
93
+ }
94
+ static bool hasCuDNN() {
95
+ return detail::getCUDAHooks().hasCuDNN();
96
+ }
97
+ static long versionCuDNN() {
98
+ return detail::getCUDAHooks().versionCuDNN();
99
+ }
100
+ static bool hasCuSOLVER() {
101
+ return detail::getCUDAHooks().hasCuSOLVER();
102
+ }
103
+ static bool hasHIP() {
104
+ return detail::getHIPHooks().hasHIP();
105
+ }
106
+ static bool hasMPS() {
107
+ return detail::getMPSHooks().hasMPS();
108
+ }
109
+ static bool hasIPU() {
110
+ return c10::impl::hasDeviceGuardImpl(c10::DeviceType::IPU);
111
+ }
112
+ static bool hasXLA() {
113
+ return c10::impl::hasDeviceGuardImpl(c10::DeviceType::XLA);
114
+ }
115
+ static bool hasXPU() {
116
+ return detail::getXPUHooks().hasXPU();
117
+ }
118
+ static bool hasLazy() {
119
+ return c10::impl::hasDeviceGuardImpl(c10::DeviceType::Lazy);
120
+ }
121
+ static bool hasORT() {
122
+ return c10::impl::hasDeviceGuardImpl(c10::DeviceType::ORT);
123
+ }
124
+ // defined in header so that getNonVariableType has ability to inline
125
+ // call_once check. getNonVariableType is called fairly frequently
126
+ void lazyInitCUDA() {
127
+ c10::call_once(thc_init, [&] { detail::getCUDAHooks().initCUDA(); });
128
+ }
129
+ void lazyInitHIP() {
130
+ c10::call_once(thh_init, [&] { detail::getHIPHooks().initHIP(); });
131
+ }
132
+ static const at::cuda::NVRTC& getNVRTC() {
133
+ return detail::getCUDAHooks().nvrtc();
134
+ }
135
+
136
+ static bool setFlushDenormal(bool on);
137
+
138
+ // NB: This method is *purely* whether or not a user requested
139
+ // that CuDNN was enabled, it doesn't actually say anything about
140
+ // whether or not CuDNN is actually usable. Use cudnn_is_acceptable
141
+ // to test this instead
142
+ bool userEnabledCuDNN() const;
143
+ void setUserEnabledCuDNN(bool e);
144
+ bool userEnabledMkldnn() const;
145
+ void setUserEnabledMkldnn(bool e);
146
+ bool benchmarkCuDNN() const;
147
+ void setBenchmarkCuDNN(bool);
148
+ int benchmarkLimitCuDNN() const;
149
+ void setBenchmarkLimitCuDNN(int);
150
+ bool deterministicCuDNN() const;
151
+ void setDeterministicCuDNN(bool);
152
+
153
+ // Note [Disabling Fused SDP Kernels]
154
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
155
+ // Flash and Memory Efficient SDP kernels are enabled by default.
156
+ // However, they can be disabled by setting
157
+ // at::globalContext().setUserEnabledFlashSDP(false) flag.
158
+ // This is useful for debugging purposes. For example, if you want to
159
+ // compare the performance of the flash SDP kernels with the unfused
160
+ // kernel, you can disable the flash SDP kernels. By disabling
161
+ // the math SDP kernel, you can force your code to use flash kernels.
162
+ // The math SDP kernel can be disabled by setting
163
+ // at::globalContext().setUserEnabledMathSDP(false) flag.
164
+ void setSDPUseFlash(bool);
165
+ bool userEnabledFlashSDP() const;
166
+
167
+ void setSDPUseMemEfficient(bool);
168
+ bool userEnabledMemEfficientSDP() const;
169
+
170
+ void setSDPUseMath(bool);
171
+ bool userEnabledMathSDP() const;
172
+
173
+ at::LinalgBackend linalgPreferredBackend() const;
174
+ void setLinalgPreferredBackend(at::LinalgBackend);
175
+
176
+ // Note [Enabling Deterministic Operations]
177
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
178
+ // Operations in PyTorch that normally act nondeterministically, but have an
179
+ // alternate deterministic implementation, should satisfy the following
180
+ // requirements:
181
+ //
182
+ // * Include this comment: "See Note [Enabling Deterministic Operations]"
183
+ //
184
+ // * Check the value of `at::globalContext().deterministicAlgorithms()` to
185
+ // toggle
186
+ // between nondeterministic and deterministic implementations.
187
+ //
188
+ // * Have an entry in the list of PyTorch operations that toggle between
189
+ // nondeterministic
190
+ // and deterministic implementations, in the docstring of
191
+ // `use_deterministic_algorithms()` in torch/__init__.py
192
+ //
193
+ // `example_func()` below shows an example of toggling between
194
+ // nondeterministic and deterministic implementations:
195
+ //
196
+ // void example_func() {
197
+ // // See Note [Enabling Deterministic Operations]
198
+ // if (at::globalContext().deterministicAlgorithms()) {
199
+ // example_func_deterministic();
200
+ // } else {
201
+ // example_func_nondeterministic();
202
+ // }
203
+ // }
204
+
205
+ bool deterministicAlgorithms() const;
206
+ bool deterministicAlgorithmsWarnOnly() const;
207
+ void setDeterministicAlgorithms(bool, bool);
208
+ bool deterministicFillUninitializedMemory() const;
209
+ void setDeterministicFillUninitializedMemory(bool);
210
+
211
+ // Note [Writing Nondeterministic Operations]
212
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
213
+ // Operations in PyTorch that act nondeterministically and do not have an
214
+ // alternate deterministic implementation should satisfy the following
215
+ // requirements:
216
+ //
217
+ // * Include this comment: "See Note [Writing Nondeterministic Operations]"
218
+ //
219
+ // * Include a comment explaining why the operation is nondeterministic.
220
+ //
221
+ // * Throw an error when `Context::deterministicAlgorithms()` is true. Most
222
+ // of the time, this should be accomplished by calling
223
+ // `at::globalContext().alertNotDeterminstic()`. However, if the
224
+ // nondeterministic behavior is caused by the CuBLAS workspace
225
+ // configuration in CUDA >= 10.2,
226
+ // `at::globalContext().alertCuBLASConfigNotDeterministic()` should be
227
+ // called instead (in this case, a comment explaining why the operation is
228
+ // nondeterministic is not necessary). See below for details on these
229
+ // methods.
230
+ //
231
+ // * Have an entry in the list of nondeterministic PyTorch operations in the
232
+ // docstring of `use_deterministic_algorithms()` in torch/__init__.py
233
+ //
234
+ // * Have a test function in `test/test_torch.py` whose name begins with
235
+ // `test_nondeterministic_alert_`. Alternatively, if CuBLAS workspace
236
+ // configuration is the reason for nondeterminism, the operation should be
237
+ // included in the `test_cublas_config_nondeterministic_alert` test. Any new
238
+ // tests should ideally follow a pattern similar to the existing ones.
239
+ //
240
+ // `example_func()` below shows an example of the comments and error-throwing
241
+ // code for a nondeterministic operation:
242
+ //
243
+ // void example_func() {
244
+ // // See Note [Writing Nondeterministic Operations]
245
+ // // Nondeterministic because <reason>
246
+ // at::globalContext().alertNondeterministic("example_func");
247
+ // ...
248
+ // }
249
+
250
+ // Throws an error if `Context::deterministicAlgorithms()` is true
251
+ static void alertNotDeterministic(c10::string_view const& caller);
252
+
253
+ // Throws an error if `Context::deterministicAlgorithms()` is true, CUDA
254
+ // >= 10.2, and CUBLAS_WORKSPACE_CONFIG is not set to either ":16:8" or
255
+ // ":4096:8". For more details:
256
+ // https://docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility
257
+ void alertCuBLASConfigNotDeterministic() const;
258
+
259
+ void setFloat32MatmulPrecision(const std::string& s);
260
+ bool allowTF32CuDNN() const;
261
+ void setAllowTF32CuDNN(bool);
262
+ bool allowTF32CuBLAS() const;
263
+ void setAllowTF32CuBLAS(bool);
264
+ Float32MatmulPrecision float32MatmulPrecision() const;
265
+ void setFloat32MatmulPrecision(Float32MatmulPrecision p);
266
+ bool allowFP16ReductionCuBLAS() const;
267
+ void setAllowFP16ReductionCuBLAS(bool);
268
+ bool allowBF16ReductionCuBLAS() const;
269
+ void setAllowBF16ReductionCuBLAS(bool);
270
+ at::QEngine qEngine() const;
271
+ void setQEngine(at::QEngine e);
272
+ static const std::vector<at::QEngine>& supportedQEngines();
273
+ static bool isXNNPACKAvailable();
274
+ void setCheckSparseTensorInvariants(bool e);
275
+ bool checkSparseTensorInvariants() const;
276
+ // This method is used to release the original weight after pre-packing.
277
+ // It should be called once before loading/running the model.
278
+ // NB: By default it is set to true for mobile builds.
279
+ void setReleaseWeightsWhenPrepacking(bool e);
280
+ bool releaseWeightsWhenPrepacking() const;
281
+
282
+ void setDisplayVmapFallbackWarnings(bool enabled);
283
+ bool areVmapFallbackWarningsEnabled() const;
284
+
285
+ void setDefaultMobileCPUAllocator();
286
+ void unsetDefaultMobileCPUAllocator();
287
+
288
+ private:
289
+ void initCUDAIfNeeded(c10::DeviceType p) {
290
+ if (p == c10::DeviceType::CUDA) {
291
+ lazyInitCUDA();
292
+ }
293
+ }
294
+ void initHIPIfNeeded(c10::DeviceType p) {
295
+ if (p == c10::DeviceType::HIP) {
296
+ lazyInitHIP();
297
+ }
298
+ }
299
+ static bool checkCuBLASConfigDeterministic();
300
+ c10::once_flag thc_init;
301
+ c10::once_flag thh_init;
302
+ bool enabled_cudnn = true;
303
+ bool deterministic_cudnn = false;
304
+ bool _deterministic_algorithms = false;
305
+ bool _deterministic_algorithms_warn_only = false;
306
+ bool _deterministic_fill_uninitialized_memory = true;
307
+ bool enabled_flashSDP = true;
308
+ bool enabled_mem_efficientSDP = true;
309
+ bool enabled_mathSDP = true;
310
+ #ifdef USE_ROCM
311
+ bool benchmark_cudnn = true;
312
+ #else
313
+ bool benchmark_cudnn = false;
314
+ #endif
315
+ Float32MatmulPrecision float32_matmul_precision =
316
+ c10::utils::check_env("TORCH_ALLOW_TF32_CUBLAS_OVERRIDE") == true
317
+ ? at::Float32MatmulPrecision::HIGH
318
+ : at::Float32MatmulPrecision::HIGHEST;
319
+ int benchmark_limit_cudnn = 10;
320
+ bool allow_tf32_cudnn = true;
321
+ bool allow_fp16_reduction_cublas = true;
322
+ bool allow_bf16_reduction_cublas = true;
323
+ bool enabled_mkldnn = true;
324
+ at::LinalgBackend linalg_preferred_backend =
325
+ c10::utils::check_env("TORCH_LINALG_PREFER_CUSOLVER") == true
326
+ ? at::LinalgBackend::Cusolver
327
+ : at::LinalgBackend::Default;
328
+ #ifdef C10_MOBILE
329
+ bool release_original_weights = true;
330
+ #else
331
+ bool release_original_weights = false;
332
+ #endif
333
+ bool display_vmap_fallback_warnings_ = false;
334
+ c10::optional<at::QEngine> quantized_engine = c10::nullopt;
335
+ bool enable_sparse_tensor_invariant_checks = false;
336
+
337
+ Allocator* prev_allocator_ptr_{nullptr};
338
+ };
339
+
340
+ TORCH_API Context& globalContext();
341
+
342
+ static inline void init() {
343
+ globalContext();
344
+ }
345
+
346
+ TORCH_API Allocator* getCPUAllocator();
347
+
348
+ static inline DeprecatedTypeProperties& getDeprecatedTypeProperties(
349
+ Backend p,
350
+ ScalarType s) {
351
+ return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
352
+ p, s);
353
+ }
354
+
355
+ static inline DeprecatedTypeProperties& CPU(ScalarType s) {
356
+ return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
357
+ Backend::CPU, s);
358
+ }
359
+
360
+ static inline DeprecatedTypeProperties& CUDA(ScalarType s) {
361
+ return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
362
+ Backend::CUDA, s);
363
+ }
364
+
365
+ static inline DeprecatedTypeProperties& HIP(ScalarType s) {
366
+ return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
367
+ Backend::HIP, s);
368
+ }
369
+
370
+ static inline DeprecatedTypeProperties& MPS(ScalarType s) {
371
+ return globalDeprecatedTypePropertiesRegistry().getDeprecatedTypeProperties(
372
+ Backend::MPS, s);
373
+ }
374
+
375
+ static inline bool hasCUDA() {
376
+ return globalContext().hasCUDA();
377
+ }
378
+
379
+ static inline bool hasMTIA() {
380
+ return globalContext().hasMTIA();
381
+ }
382
+
383
+ static inline bool hasHIP() {
384
+ return globalContext().hasHIP();
385
+ }
386
+
387
+ static inline bool hasIPU() {
388
+ return globalContext().hasIPU();
389
+ }
390
+
391
+ static inline bool hasXLA() {
392
+ return globalContext().hasXLA();
393
+ }
394
+
395
+ static inline bool hasMPS() {
396
+ return globalContext().hasMPS();
397
+ }
398
+
399
+ static inline bool hasORT() {
400
+ return globalContext().hasORT();
401
+ }
402
+
403
+ static inline bool hasXPU() {
404
+ return globalContext().hasXPU();
405
+ }
406
+
407
+ // Despite its name, this function returns the number of *CUDA* GPUs.
408
+ static inline size_t getNumGPUs() {
409
+ // WARNING: DO NOT ADD LOGIC TO HANDLE OTHER DEVICE TYPES TO THIS
410
+ // FUNCTION. If you are interested in interrogating the number of
411
+ // devices for a specific device type, add that function to the
412
+ // relevant library (e.g., similar to at::cuda::device_count())
413
+ if (hasCUDA() && hasHIP()) {
414
+ throw std::runtime_error(
415
+ "Enabling both CUDA and HIP in ATen is not supported, as HIP masquerades "
416
+ "to be CUDA (e.g., when you say CUDA, on a HIP build of ATen, this actually "
417
+ "means HIP. Rebuild PyTorch with one or the other disabled.");
418
+ } else if (hasCUDA()) {
419
+ return detail::getCUDAHooks().getNumGPUs();
420
+ } else if (hasHIP()) {
421
+ return detail::getHIPHooks().getNumGPUs();
422
+ } else {
423
+ return 0;
424
+ }
425
+ }
426
+
427
+ static inline bool hasOpenMP() {
428
+ return globalContext().hasOpenMP();
429
+ }
430
+
431
+ static inline bool hasMKL() {
432
+ return globalContext().hasMKL();
433
+ }
434
+
435
+ static inline bool hasLAPACK() {
436
+ return globalContext().hasLAPACK();
437
+ }
438
+
439
+ static inline bool hasMAGMA() {
440
+ return globalContext().hasMAGMA();
441
+ }
442
+
443
+ static inline bool hasMKLDNN() {
444
+ return globalContext().hasMKLDNN();
445
+ }
446
+
447
+ static inline void manual_seed(uint64_t seed) {
448
+ auto gen = globalContext().defaultGenerator(c10::DeviceType::CPU);
449
+ {
450
+ // See Note [Acquire lock when using random generators]
451
+ std::lock_guard<std::mutex> lock(gen.mutex());
452
+ gen.set_current_seed(seed);
453
+ }
454
+ // NB: Sometimes we build with CUDA, but we don't have any GPUs
455
+ // available. In that case, we must not seed CUDA; it will fail!
456
+ const auto cuda_num_gpus = detail::getCUDAHooks().getNumGPUs();
457
+ if (hasCUDA() && cuda_num_gpus > 0) {
458
+ for (const auto i : c10::irange(cuda_num_gpus)) {
459
+ auto cuda_gen = globalContext().defaultGenerator(
460
+ Device(at::kCUDA, static_cast<c10::DeviceIndex>(i)));
461
+ {
462
+ // See Note [Acquire lock when using random generators]
463
+ std::lock_guard<std::mutex> lock(cuda_gen.mutex());
464
+ cuda_gen.set_current_seed(seed);
465
+ }
466
+ }
467
+ }
468
+
469
+ const auto xpu_num_gpus = detail::getXPUHooks().getNumGPUs();
470
+ if (hasXPU() && xpu_num_gpus > 0) {
471
+ for (const auto i : c10::irange(xpu_num_gpus)) {
472
+ auto xpu_gen = globalContext().defaultGenerator(
473
+ Device(at::kXPU, static_cast<c10::DeviceIndex>(i)));
474
+ {
475
+ // See Note [Acquire lock when using random generators]
476
+ std::lock_guard<std::mutex> lock(xpu_gen.mutex());
477
+ xpu_gen.set_current_seed(seed);
478
+ }
479
+ }
480
+ }
481
+
482
+ if (hasMPS()) {
483
+ auto mps_gen = globalContext().defaultGenerator(c10::DeviceType::MPS);
484
+ // See Note [Acquire lock when using random generators]
485
+ std::lock_guard<std::mutex> lock(mps_gen.mutex());
486
+ mps_gen.set_current_seed(seed);
487
+ }
488
+ }
489
+
490
+ // When the global flag `allow_tf32` is set to true, cuBLAS handles are
491
+ // automatically configured to use math mode CUBLAS_TF32_TENSOR_OP_MATH.
492
+ // For some operators, such as addmv, TF32 offers no performance improvement
493
+ // but causes precision loss. To help this case, this class implements
494
+ // a RAII guard that can be used to quickly disable TF32 within its scope.
495
+ //
496
+ // Usage:
497
+ // NoTF32Guard disable_tf32;
498
+ struct TORCH_API NoTF32Guard {
499
+ NoTF32Guard();
500
+ ~NoTF32Guard();
501
+ static bool should_disable_tf32();
502
+
503
+ private:
504
+ bool changed = false;
505
+ };
506
+
507
+ #ifdef USE_ROCM
508
+ struct TORCH_API ROCmBackwardPassGuard {
509
+ ROCmBackwardPassGuard();
510
+ ~ROCmBackwardPassGuard();
511
+ static bool is_backward_pass();
512
+
513
+ private:
514
+ static thread_local bool is_backward_pass_;
515
+ };
516
+ #endif
517
+
518
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/DimVector.h ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ #pragma once
2
+ #include <ATen/core/DimVector.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/Dimname.h ADDED
@@ -0,0 +1 @@
 
 
1
+ #include <ATen/core/Dimname.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/DynamicLibrary.h ADDED
@@ -0,0 +1,34 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/Utils.h>
4
+ #include <c10/macros/Export.h>
5
+ #include <c10/util/Exception.h>
6
+
7
+ namespace c10 {
8
+
9
+ class DynamicLibraryError : public Error {
10
+ using Error::Error;
11
+ };
12
+
13
+ } // namespace c10
14
+
15
+ namespace at {
16
+
17
+ struct DynamicLibrary {
18
+ AT_DISALLOW_COPY_AND_ASSIGN(DynamicLibrary);
19
+
20
+ TORCH_API DynamicLibrary(
21
+ const char* name,
22
+ const char* alt_name = nullptr,
23
+ bool leak_handle = false);
24
+
25
+ TORCH_API void* sym(const char* name);
26
+
27
+ TORCH_API ~DynamicLibrary();
28
+
29
+ private:
30
+ bool leak_handle;
31
+ void* handle = nullptr;
32
+ };
33
+
34
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/EmptyTensor.h ADDED
@@ -0,0 +1,160 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ #include <ATen/core/TensorBase.h>
3
+
4
+ namespace at::detail {
5
+
6
+ inline void check_size_nonnegative(ArrayRef<int64_t> size) {
7
+ for (const auto& x : size) {
8
+ TORCH_CHECK(
9
+ x >= 0,
10
+ "Trying to create tensor with negative dimension ",
11
+ x,
12
+ ": ",
13
+ size);
14
+ }
15
+ }
16
+
17
+ inline void check_size_nonnegative(ArrayRef<c10::SymInt> size) {
18
+ for (const auto& x : size) {
19
+ TORCH_CHECK(
20
+ x.expect_size(__FILE__, __LINE__),
21
+ "Trying to create tensor with negative dimension ",
22
+ x,
23
+ ": ",
24
+ size);
25
+ }
26
+ }
27
+
28
+ TORCH_API size_t computeStorageNbytesContiguous(
29
+ IntArrayRef sizes,
30
+ size_t itemsize,
31
+ size_t storage_offset = 0);
32
+ TORCH_API SymInt computeStorageNbytesContiguous(
33
+ SymIntArrayRef sizes,
34
+ const SymInt& itemsize,
35
+ const SymInt& storage_offset = 0);
36
+ TORCH_API size_t computeStorageNbytes(
37
+ IntArrayRef sizes,
38
+ IntArrayRef strides,
39
+ size_t itemsize,
40
+ size_t storage_offset = 0);
41
+ TORCH_API SymInt computeStorageNbytes(
42
+ SymIntArrayRef sizes,
43
+ SymIntArrayRef strides,
44
+ const SymInt& itemsize,
45
+ const SymInt& storage_offset = 0);
46
+
47
+ TORCH_API TensorBase empty_generic(
48
+ IntArrayRef size,
49
+ c10::Allocator* allocator,
50
+ c10::DispatchKeySet ks,
51
+ ScalarType scalar_type,
52
+ c10::optional<c10::MemoryFormat> memory_format_opt);
53
+
54
+ TORCH_API TensorBase empty_strided_generic(
55
+ IntArrayRef size,
56
+ IntArrayRef stride,
57
+ c10::Allocator* allocator,
58
+ c10::DispatchKeySet ks,
59
+ ScalarType scalar_type);
60
+
61
+ TORCH_API TensorBase empty_strided_symint_generic(
62
+ SymIntArrayRef size,
63
+ SymIntArrayRef stride,
64
+ c10::Allocator* allocator,
65
+ c10::DispatchKeySet ks,
66
+ ScalarType scalar_type);
67
+
68
+ TORCH_API TensorBase empty_cpu(
69
+ IntArrayRef size,
70
+ ScalarType dtype,
71
+ bool pin_memory = false,
72
+ c10::optional<c10::MemoryFormat> memory_format_opt = c10::nullopt);
73
+
74
+ TORCH_API TensorBase empty_cpu(
75
+ IntArrayRef size,
76
+ c10::optional<ScalarType> dtype_opt,
77
+ c10::optional<Layout> layout_opt,
78
+ c10::optional<Device> device_opt,
79
+ c10::optional<bool> pin_memory_opt,
80
+ c10::optional<c10::MemoryFormat> memory_format_opt);
81
+
82
+ TORCH_API TensorBase empty_cpu(IntArrayRef size, const TensorOptions& options);
83
+
84
+ TORCH_API TensorBase empty_strided_cpu(
85
+ IntArrayRef size,
86
+ IntArrayRef stride,
87
+ ScalarType dtype,
88
+ bool pin_memory = false);
89
+
90
+ TORCH_API TensorBase empty_strided_cpu(
91
+ IntArrayRef size,
92
+ IntArrayRef stride,
93
+ c10::optional<ScalarType> dtype_opt,
94
+ c10::optional<Layout> layout_opt,
95
+ c10::optional<Device> device_opt,
96
+ c10::optional<bool> pin_memory_opt);
97
+
98
+ TORCH_API TensorBase empty_strided_cpu(
99
+ IntArrayRef size,
100
+ IntArrayRef stride,
101
+ const TensorOptions& options);
102
+
103
+ TORCH_API TensorBase empty_meta(
104
+ IntArrayRef size,
105
+ ScalarType dtype,
106
+ c10::optional<c10::MemoryFormat> memory_format_opt = c10::nullopt);
107
+
108
+ TORCH_API TensorBase empty_meta(
109
+ IntArrayRef size,
110
+ c10::optional<ScalarType> dtype_opt,
111
+ c10::optional<Layout> layout_opt,
112
+ c10::optional<Device> device_opt,
113
+ c10::optional<bool> pin_memory_opt,
114
+ c10::optional<c10::MemoryFormat> memory_format_opt);
115
+
116
+ TORCH_API TensorBase empty_symint_meta(
117
+ SymIntArrayRef size,
118
+ c10::optional<ScalarType> dtype_opt,
119
+ c10::optional<Layout> layout_opt,
120
+ c10::optional<Device> device_opt,
121
+ c10::optional<bool> pin_memory_opt,
122
+ c10::optional<c10::MemoryFormat> memory_format_opt);
123
+
124
+ TORCH_API TensorBase empty_meta(IntArrayRef size, const TensorOptions& options);
125
+
126
+ TORCH_API TensorBase
127
+ empty_strided_meta(IntArrayRef size, IntArrayRef stride, ScalarType dtype);
128
+
129
+ TORCH_API TensorBase empty_strided_meta(
130
+ IntArrayRef size,
131
+ IntArrayRef stride,
132
+ c10::optional<ScalarType> dtype_opt,
133
+ c10::optional<Layout> layout_opt,
134
+ c10::optional<Device> device_opt,
135
+ c10::optional<bool> pin_memory_opt);
136
+
137
+ TORCH_API TensorBase empty_strided_meta(
138
+ IntArrayRef size,
139
+ IntArrayRef stride,
140
+ const TensorOptions& options);
141
+
142
+ TORCH_API TensorBase empty_strided_symint_meta(
143
+ SymIntArrayRef size,
144
+ SymIntArrayRef stride,
145
+ ScalarType dtype);
146
+
147
+ TORCH_API TensorBase empty_strided_symint_meta(
148
+ SymIntArrayRef size,
149
+ SymIntArrayRef stride,
150
+ c10::optional<ScalarType> dtype_opt,
151
+ c10::optional<Layout> layout_opt,
152
+ c10::optional<Device> device_opt,
153
+ c10::optional<bool> pin_memory_opt);
154
+
155
+ TORCH_API TensorBase empty_strided_symint_meta(
156
+ SymIntArrayRef size,
157
+ SymIntArrayRef stride,
158
+ const TensorOptions& options);
159
+
160
+ } // namespace at::detail
videollama2/lib/python3.10/site-packages/torch/include/ATen/Formatting.h ADDED
@@ -0,0 +1 @@
 
 
1
+ #include <ATen/core/Formatting.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/FuncTorchTLS.h ADDED
@@ -0,0 +1,46 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/macros/Macros.h>
4
+ #include <memory>
5
+
6
+ namespace at::functorch {
7
+
8
+ // NOTE [functorch TLS in pytorch/pytorch]
9
+ //
10
+ // functorch lives out-of-tree. However, it has some TLS that needs to be
11
+ // propagated. The solution for that is we store a pointer to the TLS
12
+ // inside pytorch/pytorch and extend FuncTorchTLSBase inside functorch to
13
+ // include whatever functorch needs.
14
+ //
15
+ // We need to store a pointer due to the indirection:
16
+ // inside functorch, we will create a subclass of FunctorchTLSBase called
17
+ // FuncTorchTLSImpl that actually contains metadata, like the DynamicLayerStack.
18
+ // FuncTorchTLSBase doesn't have any metadata because it hasn't been defined
19
+ // yet.
20
+ //
21
+ // Here in pytorch/pytorch, we will pass around FuncTorchTLSBase*, but inside
22
+ // functorch, we will assign a FuncTorchTLSImpl* to the FunctorchTLSBase*.
23
+ // We can't directly pass around FunctorchTLSBase (without a pointer) because
24
+ // FuncTorchTLSImpl does not fit inside a FuncTorchTLSBase by virtue of having
25
+ // more elements.
26
+ struct TORCH_API FuncTorchTLSBase {
27
+ virtual ~FuncTorchTLSBase() = default;
28
+ virtual std::unique_ptr<FuncTorchTLSBase> deepcopy() const = 0;
29
+
30
+ virtual int64_t checkSupportsSingleLevelAutogradFunction() const = 0;
31
+ virtual void checkSupportsCppAutogradFunction() const = 0;
32
+ virtual void checkSupportsInplaceRequiresGrad() const = 0;
33
+ virtual void checkSupportsRetainGrad() const = 0;
34
+ };
35
+
36
+ // returns deepcopy of the functorch tls
37
+ TORCH_API std::unique_ptr<FuncTorchTLSBase> getCopyOfFuncTorchTLS();
38
+
39
+ // sets the functorch tls. always does a deep copy.
40
+ TORCH_API void setFuncTorchTLS(
41
+ const std::shared_ptr<const FuncTorchTLSBase>& state);
42
+
43
+ // get a mutable reference to the functorch tls
44
+ TORCH_API std::unique_ptr<FuncTorchTLSBase>& functorchTLSAccessor();
45
+
46
+ } // namespace at::functorch
videollama2/lib/python3.10/site-packages/torch/include/ATen/FunctionalStorageImpl.h ADDED
@@ -0,0 +1,124 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/Tensor.h>
4
+
5
+ namespace at::functionalization {
6
+
7
+ // See Note [Functionalization Pass In Core]
8
+
9
+ // ViewMeta is a class used by the functionalization pass to navigate between
10
+ // a base tensor and a view tensor.
11
+ // For example, if I call `b = a.view1(...)`
12
+ // the functionalization pass will generate and store a ViewMeta on b that looks
13
+ // like:
14
+ //
15
+ // ViewMeta(
16
+ // [<captures>](const Tensor& base, int64_t mutated_view_idx) {
17
+ // return base.view1(...);
18
+ // },
19
+ // [<captures>](const at::Tensor& base, const at::Tensor& mutated_view,
20
+ // int64_t mutated_view_idx) -> at::Tensor {
21
+ // return at::functionalization::impl::view1_inverse(base, mutated_view,
22
+ // ...);
23
+ // }
24
+ //
25
+ // The forward_fn lambda describes how to replay view1 on a tensor.
26
+ //
27
+ // The reverse_fn lambda describes how, given a tensor that is already a view,
28
+ // how to get the corresponding base tensor. See Note [Functionalization Pass:
29
+ // View Inverses] for details.
30
+ struct ViewMeta {
31
+ ViewMeta(
32
+ std::function<Tensor(const Tensor&, int64_t)> forward,
33
+ std::function<Tensor(const Tensor&, const Tensor&, int64_t)> reverse,
34
+ bool is_multi_output = false,
35
+ int64_t out_idx = 0)
36
+ : forward_fn(std::move(forward)),
37
+ reverse_fn(std::move(reverse)),
38
+ out_index(out_idx),
39
+ is_multi_output(is_multi_output) {}
40
+
41
+ std::function<Tensor(const Tensor&, int64_t)> forward_fn;
42
+ std::function<Tensor(const Tensor&, const Tensor&, int64_t)> reverse_fn;
43
+ // See Note [out_idx in ViewMeta]
44
+ int64_t out_index;
45
+
46
+ // Tells us if this is a multi-output view
47
+ bool is_multi_output;
48
+
49
+ // Returns a copy of the current ViewMeta, if out_idx matches the current
50
+ // out_index. Otherwise, returns a new ViewMeta with the same forward/reverse
51
+ // functions, but a new out index.
52
+ ViewMeta to_out_idx(int64_t out_idx);
53
+ };
54
+
55
+ // FunctionalStorageImpl is a subclass of StorageImpl used by the
56
+ // functionalization pass. It has no underlying data (similar to meta storage).
57
+ // It also knows how to reflect mutations to tensors in the absence of a valid
58
+ // data pointer.
59
+ //
60
+ // A storage represents the state shared by (potentially multiple) views of the
61
+ // same tensor. For example, in the following code:
62
+ //
63
+ // b = a.view1(...)
64
+ // c = b.view2(...)
65
+ // b.add_(1)
66
+ // --> storage.add_update(b, {view1_meta})
67
+ //
68
+ // The call to add_(1) will result in a call to alias.add_update(b,
69
+ // {view1_meta}), queueing up the mutation from b onto the alias. Later, suppose
70
+ // c is used in an expression (e.g. you try to print c, or pass it to an
71
+ // operator). Doing so will involve "syncing" c. First we apply any pending
72
+ // updates to the alias, and then we regenerate c by replaying its views off of
73
+ // the updated alias. E.g:
74
+ //
75
+ // print(str(c))
76
+ // --> c.sync_()
77
+ // --> alias.apply_updates() // after this, the alias will be updated to
78
+ // reflect the mutation to b
79
+ struct TORCH_API FunctionalStorageImpl : public c10::StorageImpl {
80
+ public:
81
+ struct Update {
82
+ const at::Tensor new_val;
83
+ const std::vector<ViewMeta> view_metas;
84
+ };
85
+
86
+ explicit FunctionalStorageImpl(const Tensor& value);
87
+
88
+ void add_update(
89
+ const Tensor& updated_val,
90
+ const std::vector<ViewMeta>& view_metas);
91
+ bool apply_updates();
92
+ const Tensor& base() {
93
+ return base_;
94
+ }
95
+ size_t generation() const {
96
+ return generation_;
97
+ }
98
+ void freeze() {
99
+ frozen_ = true;
100
+ }
101
+
102
+ ~FunctionalStorageImpl() override = default;
103
+
104
+ private:
105
+ // NB: base_ should always point to a tensor BELOW the current
106
+ // functionalization layer. This is mainly to avoid reference cycles. e.g.
107
+ // given `b = a.view(...)` Both a.storage_ and b.storage_ are a
108
+ // FunctionStorageImpl containing an Walualias, with contains a Tensor
109
+ // `base_`. In this case (where a and b are FunctionalTensorWrapper's), base_
110
+ // should point not to a, but to a's unwrapped value, a.value_` See Note
111
+ // [Functionalization: Walualias Removal] for a diagram that shows this
112
+ // visually.
113
+ at::Tensor base_;
114
+ std::vector<Update> updates_;
115
+ // generation_ gets incremented every time a mutation is queued onto the
116
+ // alias. It is used to determine if a given tensor is "up to date", or if it
117
+ // needs to be regenerated from the alias.
118
+ size_t generation_ = 0;
119
+ // If frozen, no more mutations are allowed on this storage. Once frozen, a
120
+ // storage cannot be unfrozen.
121
+ bool frozen_ = false;
122
+ };
123
+
124
+ } // namespace at::functionalization
videollama2/lib/python3.10/site-packages/torch/include/ATen/FunctionalTensorWrapper.h ADDED
@@ -0,0 +1,392 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+
2
+ #pragma once
3
+
4
+ #include <ATen/ArrayRef.h>
5
+ #include <ATen/FunctionalStorageImpl.h>
6
+ #include <ATen/core/IListRef.h>
7
+ #include <ATen/core/List.h>
8
+ #include <ATen/core/boxing/BoxedKernel.h>
9
+ #include <ATen/core/boxing/impl/boxing.h>
10
+ #include <ATen/core/dispatch/Dispatcher.h>
11
+
12
+ #include <c10/core/DispatchKey.h>
13
+
14
+ namespace at {
15
+
16
+ // Note [Functionalization Pass In Core]
17
+ // The Functionalization pass is used to remove aliasing from a pytorch program.
18
+ //
19
+ // This is useful for backends that don't support aliasing, like XLA and Vulkan.
20
+ // It's also necessary in order to remove mutation from a program, which is
21
+ // needed in Functorch.
22
+ //
23
+ // Consider this program:
24
+ // a = torch.ones(...)
25
+ // b = a.view(...)
26
+ // b.add_(1)
27
+ //
28
+ // In this program, b is meant to alias with a due to the use of view(). At the
29
+ // end of the program, both a and b are full of 2's. However, backends that
30
+ // don't support aliasing aren't able to correctly implement the view()
31
+ // operator. Instead, they can opt into the Functionalization pass, which will
32
+ // sit between the user and the backend, and provide the necessary aliasing
33
+ // logic.
34
+ //
35
+ // The functionalization pass will turn the above program into a slightly
36
+ // different program that has the same semantics, transparently to the user,
37
+ // that backends like XLA/Vulkan are able to implement a = torch.ones(...) b =
38
+ // a.view_copy(...) # view() replaced with view_copy(). Backends like
39
+ // XLA/Vulkan can implement this! b.add_(1) a.add_(1) # Our functionalization
40
+ // pass machinery knows that a and b are aliased - it applies b's mutation to a
41
+ // too.
42
+ //
43
+ // So, how does the functionalization pass keep track of which tensors are
44
+ // aliased? The pass works by wrapping EVERY tensor in the program inside of a
45
+ // FunctionalTensorWrapper, which knows about its alias'd tensors.
46
+ //
47
+ // See Note [Functionalization: Alias Removal] for details on the aliasing
48
+ // machinery. See Note [Functionalization: Mutation Removal] for details on
49
+ // mutation removal.
50
+ struct TORCH_API FunctionalTensorWrapper : public c10::TensorImpl {
51
+ explicit FunctionalTensorWrapper(const Tensor& value);
52
+ // Additional constructor to create a FunctionalTensorWrapper directly from an
53
+ // underlying tensor that was created from a view. For example, the code b =
54
+ // a.view1() will generate a constructor call to FunctionalTensorWrapper(b, a,
55
+ // view1_meta)
56
+ explicit FunctionalTensorWrapper(
57
+ const Tensor& view_value,
58
+ const FunctionalTensorWrapper* base,
59
+ functionalization::ViewMeta meta);
60
+
61
+ // Get the underlying, actual tensor, that doesn't know anything about
62
+ // functionalization.
63
+ const Tensor& value() const {
64
+ return value_;
65
+ };
66
+ // The concept of "level" is only ever important to functorch; it's exposed
67
+ // here as more of a hook for functorch to use.
68
+ int64_t level() const {
69
+ return level_;
70
+ };
71
+ void set_level(int64_t level) {
72
+ level_ = level;
73
+ }
74
+ bool has_metadata_mutation() const {
75
+ return has_metadata_mutation_;
76
+ };
77
+
78
+ // Denotes a mutation that's hidden from autograd,
79
+ // e.g. for the purposes of passing a tensor to a triton kernel
80
+ void mark_mutation_hidden_from_autograd() {
81
+ mutation_hidden_from_autograd_counter_++;
82
+ }
83
+ void mark_mutation_during_no_grad_or_inference_mode() {
84
+ mutation_during_no_grad_or_inference_mode_++;
85
+ }
86
+ // Are all the mutations happening to the tensor hidden from autograd
87
+ bool are_all_mutations_hidden_from_autograd() const {
88
+ return mutation_hidden_from_autograd_counter_ == mutation_counter_;
89
+ }
90
+ // Did all mutations happen under no_grad or inference_mode
91
+ // (We also need to ignore mutations fully hidden from autograd here)
92
+ bool are_all_mutations_under_no_grad_or_inference_mode() const {
93
+ return mutation_hidden_from_autograd_counter_ +
94
+ mutation_during_no_grad_or_inference_mode_ ==
95
+ mutation_counter_;
96
+ }
97
+
98
+ // Sync's the underlying tensor with its alias, if it's out of date. This
99
+ // involves two steps: 1) Apply any pending updates/mutations to the alias 2)
100
+ // Replay the views (if any) to regenerate the current tensor off of the
101
+ // updated alias.
102
+ void sync_();
103
+ // Performs step (1) of the sync. This is its own public API because it's
104
+ // needed by view_inplace ops like transpose_. See Note [Functionalization
105
+ // Pass - Inplace View Ops]
106
+ void regenerate_from_base();
107
+ // Performs step (2) of the sync. This is its own public API because it's
108
+ // needed by functorch. functorch wants to make sure that all input tensors to
109
+ // a functionalized program have been properly synced so it can properly
110
+ // propagate mutations to inputs. It can't just call sync_(), because the
111
+ // FunctionalTensorWrapper will look like it has no aliases and sync_ will be
112
+ // a noop. We use the reference count on storage_ to determine if the wrapper
113
+ // is aliased, and by the time functorch is ready to propagate updates to
114
+ // inputs, any intermediate views of the input created by the program will
115
+ // have been deallocated. This function also returns whether or not the base
116
+ // actually had any updates to apply.
117
+ bool apply_updates();
118
+ // Takes the current state of value_ and snapshots it, sending it as a pending
119
+ // update to the alias.
120
+ void commit_update();
121
+ // When any tensor is mutated, the tensor increments its alias's "generation".
122
+ // Separately, each tensor maintains its own "generation" counter, which is
123
+ // used to determine if it's up-to-date with its alias. The act of syncing a
124
+ // tensor will set a tensor's generation equal to its alias's generation.
125
+ bool is_up_to_date() const;
126
+ // Freezes the storage of this tensor, preventing subsequent mutations
127
+ void freeze_storage() const;
128
+ // Every FunctionalTensorWrapper contains a vector<ViewMeta> objects
129
+ // describing the series of view ops that ran to generate the current tensor
130
+ // from the base tensor. This method is used by inplace-view ops like
131
+ // transpose_. It appends a ViewMeta to the existing stack, and refreshes the
132
+ // tensor by replaying the views off of the alias.
133
+ void mutate_view_meta(at::functionalization::ViewMeta meta);
134
+
135
+ // Custom implementation of self.set_(src)
136
+ void set__impl(const FunctionalTensorWrapper* other);
137
+
138
+ // Returns whether the current tensor's data was ever mutated
139
+ bool has_data_mutation();
140
+ //
141
+ // Returns whether the current FunctionalTensorWrapper
142
+ // experienced a set_() call.
143
+ bool was_storage_changed() {
144
+ return was_storage_changed_;
145
+ }
146
+
147
+ // The functionalization pass can be used to remove mutations.
148
+ // It does so by replacing any mutation op with it's corresponding
149
+ // out-of-place op, followed by a call to replace_(). e.g:
150
+ //
151
+ // a.add_(1)
152
+ //
153
+ // will turn into:
154
+ //
155
+ // tmp = a.add(1)
156
+ // a.replace_(tmp)
157
+ //
158
+ // replace_() swaps out the wrapped tensor, value_, with tmp.
159
+ void replace_(const Tensor& other);
160
+
161
+ bool is_multi_output_view() {
162
+ return is_multi_output_view_;
163
+ }
164
+
165
+ // See Note[resize_() in functionalization pass]
166
+ void maybe_replace_storage(const Tensor& other);
167
+
168
+ // Replaces the storage with a new functional storage,
169
+ // and clears the view_metas_ stack.
170
+ // WARNING: Calling this function will sever the aliasing relationship between
171
+ // the current FunctionalTensorWrapper and any of its outstanding aliases.
172
+ // Please only call if you know what you're doing.
173
+ void _unsafe_reset_storage();
174
+
175
+ c10::intrusive_ptr<TensorImpl> shallow_copy_and_detach(
176
+ const c10::VariableVersion& version_counter,
177
+ bool allow_tensor_metadata_change) const override;
178
+
179
+ c10::intrusive_ptr<TensorImpl> shallow_copy_and_detach(
180
+ c10::VariableVersion&& version_counter,
181
+ bool allow_tensor_metadata_change) const override;
182
+
183
+ ~FunctionalTensorWrapper() override = default;
184
+
185
+ // FunctionalTensorWrapper overrides all custom size/stride function,
186
+ // so that if the inner tensor has a custom implementation
187
+ // we make sure to call that implementation.
188
+ at::IntArrayRef sizes_custom() const override;
189
+ at::IntArrayRef strides_custom() const override;
190
+ int64_t dim_custom() const override;
191
+ int64_t numel_custom() const override;
192
+ bool is_contiguous_custom(at::MemoryFormat memory_format) const override;
193
+ c10::SymIntArrayRef sym_sizes_custom() const override;
194
+ c10::SymInt sym_size_custom(int64_t d) const override;
195
+ c10::SymIntArrayRef sym_strides_custom() const override;
196
+ c10::SymInt sym_storage_offset_custom() const override;
197
+ c10::Device device_custom() const override;
198
+
199
+ private:
200
+ const char* tensorimpl_type_name() const override;
201
+ void set_constructor_metadata();
202
+ functionalization::FunctionalStorageImpl* functional_storage_impl() const;
203
+
204
+ // This is used to re-implement shallow_copy_and_detach for
205
+ // FunctionalTensorWrapper. The implementation is identical, but we just need
206
+ // to return a subclass instead of a plain TensorImpl.
207
+ // TODO: maybe it's possible to arrange for that to happen automatically
208
+ // without an override here?
209
+ template <typename VariableVersion>
210
+ c10::intrusive_ptr<TensorImpl> shallow_copy_and_detach_core(
211
+ VariableVersion&& version_counter,
212
+ bool allow_tensor_metadata_change) const;
213
+
214
+ // Note that value is not taken by reference: internally, the wrapper will
215
+ // change the value tensor that it points to over time.
216
+ Tensor value_;
217
+ int64_t level_;
218
+ // These two counters are used for identifying
219
+ // whether all the mutations on a given tensor are hidden from autograd or
220
+ // not. If we have an input mutation that is hidden from autograd, then once
221
+ // we convert the input mutation to a copy_() we know it will be safe to hide
222
+ // the copy_() from autograd as well.
223
+ uint64_t mutation_counter_ = 0;
224
+ uint64_t mutation_hidden_from_autograd_counter_ = 0;
225
+ uint64_t mutation_during_no_grad_or_inference_mode_ = 0;
226
+ bool has_metadata_mutation_ = false;
227
+ bool is_multi_output_view_ = false;
228
+ // Did the tensor experience a set_() call.
229
+ bool was_storage_changed_ = false;
230
+
231
+ size_t generation_ = 0;
232
+ std::vector<at::functionalization::ViewMeta> view_metas_;
233
+ };
234
+
235
+ // Utility functions for the functionalization pass.
236
+
237
+ namespace functionalization {
238
+ namespace impl {
239
+
240
+ TORCH_API inline FunctionalTensorWrapper* unsafeGetFunctionalWrapper(
241
+ const Tensor& tensor) {
242
+ auto functional_impl =
243
+ static_cast<FunctionalTensorWrapper*>(tensor.unsafeGetTensorImpl());
244
+ TORCH_INTERNAL_ASSERT_DEBUG_ONLY(functional_impl != nullptr);
245
+ return functional_impl;
246
+ }
247
+
248
+ TORCH_API bool isFunctionalTensor(const at::Tensor& tensor);
249
+ TORCH_API bool isFunctionalTensor(const c10::optional<Tensor>& t);
250
+ TORCH_API bool isFunctionalTensor(
251
+ const c10::List<c10::optional<Tensor>>& t_list);
252
+ TORCH_API bool isFunctionalTensor(ITensorListRef list);
253
+
254
+ TORCH_API Tensor to_functional_tensor(const Tensor& tensor);
255
+ TORCH_API c10::optional<Tensor> to_functional_tensor(
256
+ const c10::optional<Tensor>& tensor);
257
+ TORCH_API c10::List<c10::optional<Tensor>> to_functional_tensor(
258
+ const c10::List<c10::optional<Tensor>>& t_list);
259
+ TORCH_API std::vector<Tensor> to_functional_tensor(ITensorListRef t_list);
260
+
261
+ TORCH_API void freeze_functional_tensor(const Tensor& tensor);
262
+
263
+ TORCH_API Tensor
264
+ from_functional_tensor(const Tensor& tensor, bool assert_functional = true);
265
+ TORCH_API c10::optional<Tensor> from_functional_tensor(
266
+ const c10::optional<Tensor>& t,
267
+ bool assert_functional = true);
268
+ TORCH_API c10::List<c10::optional<Tensor>> from_functional_tensor(
269
+ const c10::List<c10::optional<Tensor>>& t_list);
270
+ TORCH_API std::vector<Tensor> from_functional_tensor(ITensorListRef t_list);
271
+
272
+ TORCH_API void sync(const at::Tensor& t);
273
+ TORCH_API void sync(const c10::optional<Tensor>& t);
274
+ TORCH_API void sync(const c10::List<c10::optional<Tensor>>& t_list);
275
+ TORCH_API void sync(ITensorListRef t_list);
276
+
277
+ TORCH_API void replace_(const Tensor& functional_tensor, const Tensor& other);
278
+ TORCH_API void replace_(
279
+ const ITensorListRef functional_tensor,
280
+ ITensorListRef other);
281
+
282
+ TORCH_API void commit_update(const Tensor& functional_tensor);
283
+ TORCH_API void commit_update(ITensorListRef functional_tensor);
284
+
285
+ TORCH_API void unsafe_reset_storage(const Tensor& functional_tensor);
286
+
287
+ TORCH_API void mark_mutation_hidden_from_autograd(
288
+ const Tensor& functional_tensor);
289
+
290
+ TORCH_API bool are_all_mutations_hidden_from_autograd(
291
+ const Tensor& functional_tensor);
292
+
293
+ TORCH_API bool are_all_mutations_under_no_grad_or_inference_mode(
294
+ const Tensor& functional_tensor);
295
+
296
+ // These two methods are XLA-specific logic and are no-ops
297
+ // for the normal functionalization flow.
298
+ TORCH_API void propagate_xla_data(
299
+ const Tensor& functional_tensor,
300
+ const Tensor& other);
301
+ TORCH_API void propagate_xla_data(
302
+ const ITensorListRef functional_tensor,
303
+ ITensorListRef other);
304
+
305
+ Tensor create_functional_tensor_with_view_meta(
306
+ const Tensor& view_to_wrap,
307
+ const Tensor& base,
308
+ functionalization::ViewMeta meta,
309
+ int64_t out_idx = 0);
310
+ std::vector<Tensor> create_functional_tensor_with_view_meta(
311
+ ITensorListRef view_to_wrap,
312
+ const Tensor& base,
313
+ functionalization::ViewMeta meta);
314
+
315
+ void mutate_view_meta(const Tensor& self, functionalization::ViewMeta meta);
316
+
317
+ void set_sizes_strides_offset(const Tensor& out, const Tensor& meta_out);
318
+ void set_sizes_strides_offset(
319
+ const std::vector<Tensor>& outs,
320
+ const std::vector<Tensor>& meta_outs);
321
+
322
+ // ~~~~~ TLS used in functionalization ~~~~~
323
+
324
+ TORCH_API bool getFunctionalizationReapplyViewsTLS();
325
+ TORCH_API void setFunctionalizationReapplyViewsTLS(bool reapply_views);
326
+
327
+ class TORCH_API FunctionalizationReapplyViewsGuard {
328
+ public:
329
+ FunctionalizationReapplyViewsGuard(bool reapply_views)
330
+ : prev_(getFunctionalizationReapplyViewsTLS()) {
331
+ setFunctionalizationReapplyViewsTLS(reapply_views);
332
+ }
333
+
334
+ ~FunctionalizationReapplyViewsGuard() {
335
+ setFunctionalizationReapplyViewsTLS(prev_);
336
+ }
337
+
338
+ FunctionalizationReapplyViewsGuard(
339
+ const FunctionalizationReapplyViewsGuard&) = delete;
340
+ FunctionalizationReapplyViewsGuard operator=(
341
+ const FunctionalizationReapplyViewsGuard&) = delete;
342
+ FunctionalizationReapplyViewsGuard(FunctionalizationReapplyViewsGuard&&) =
343
+ delete;
344
+ FunctionalizationReapplyViewsGuard operator=(
345
+ FunctionalizationReapplyViewsGuard&&) = delete;
346
+
347
+ private:
348
+ bool prev_;
349
+ };
350
+
351
+ } // namespace impl
352
+
353
+ // Helper function to call an out-of-place composite aten kernel that may use
354
+ // mutations / views internally, and functionalize them.
355
+ TORCH_API void functionalize_op_helper(
356
+ const c10::OperatorHandle& op,
357
+ torch::jit::Stack* stack);
358
+
359
+ template <class Op, bool symint, class ReturnType, class... ParameterTypes>
360
+ struct _functionalize_aten_op final {};
361
+
362
+ template <class Op, bool symint, class ReturnType, class... ParameterTypes>
363
+ struct _functionalize_aten_op<Op, symint, ReturnType(ParameterTypes...)> final {
364
+ static ReturnType call(
365
+ typename c10::maybe_keep_symint<symint, ParameterTypes>::type... args) {
366
+ using FuncType = ReturnType(
367
+ typename c10::maybe_keep_symint<symint, ParameterTypes>::type...);
368
+ auto op = c10::Dispatcher::singleton()
369
+ .findSchemaOrThrow(
370
+ (const char*)Op::name, (const char*)Op::overload_name)
371
+ .typed<FuncType>();
372
+
373
+ return c10::impl::BoxedKernelWrapper<FuncType>::call(
374
+ c10::BoxedKernel::makeFromFunction<functionalize_op_helper>(),
375
+ op,
376
+ // BoxedKernelWrapper knows to ignore this keyset argument,
377
+ // because functionalize_op_helper doesn't take in a DispatchKeySet
378
+ c10::DispatchKeySet(),
379
+ args...);
380
+ }
381
+ };
382
+
383
+ template <class Op>
384
+ using functionalize_aten_op =
385
+ _functionalize_aten_op<Op, false, typename Op::schema>;
386
+
387
+ template <class Op>
388
+ using functionalize_aten_op_symint =
389
+ _functionalize_aten_op<Op, true, typename Op::schema>;
390
+
391
+ } // namespace functionalization
392
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/Functions.h ADDED
@@ -0,0 +1,1405 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Functions.h
4
+
5
+ #ifdef TORCH_ASSERT_NO_OPERATORS
6
+ #error This change adds a dependency on native_functions.yaml, \
7
+ meaning the file will need to be re-compiled every time an operator \
8
+ is changed or added. Consider if your change would be better placed in \
9
+ another file, or if a more specific header might achieve the same goal. \
10
+ See NOTE: [Tensor vs. TensorBase]
11
+ #endif
12
+
13
+ #if defined(AT_PER_OPERATOR_HEADERS) && defined(TORCH_ASSERT_ONLY_METHOD_OPERATORS)
14
+ #error This change adds a dependency on all pytorch operators, meaning the \
15
+ file will need to be re-compiled every time an operator is changed or added. \
16
+ Consider including a specific operator from <ATen/ops/{my_operator}.h> and \
17
+ see NOTE [TORCH_ASSERT_ONLY_METHOD_OPERATORS].
18
+ #endif
19
+
20
+ // NOTE: [TORCH_ASSERT_ONLY_METHOD_OPERATORS]
21
+ //
22
+ // In ATen, certain generated headers files include the definitions of
23
+ // every single operator in PyTorch. Unfortunately this means every
24
+ // time an operator signature is updated or changed in
25
+ // native_functions.yaml, you (and every other PyTorch developer) need
26
+ // to recompile every source file that includes any of these headers.
27
+ //
28
+ // To break up these header dependencies, and improve incremental
29
+ // build times for all PyTorch developers. These headers are split
30
+ // into per-operator headers in the `ATen/ops` folder. This limits
31
+ // incremental builds to only changes to methods of `Tensor`, or files
32
+ // that use the specific operator being changed. With `at::sum` as an
33
+ // example, you should include
34
+ //
35
+ // <ATen/ops/sum.h> // instead of ATen/Functions.h
36
+ // <ATen/ops/sum_native.h> // instead of ATen/NativeFunctions.h
37
+ // <ATen/ops/sum_ops.h> // instead of ATen/Operators.h
38
+ // <ATen/ops/sum_cpu_dispatch.h> // instead of ATen/CPUFunctions.h
39
+ //
40
+ // However, even if you're careful to use this in your own code.
41
+ // `Functions.h` might be included indirectly through another header
42
+ // without you realising. To avoid this, you can add
43
+ //
44
+ // #define TORCH_ASSERT_ONLY_METHOD_OPERATORS
45
+ //
46
+ // to the top of your source file. This way any time the non-specific
47
+ // headers are included, the compiler will error out.
48
+ //
49
+ // Also, be aware that `ops` are not available in all build
50
+ // configurations (namely fb-internal) so you must guard these
51
+ // includes with `#ifdef AT_PER_OPERATOR_HEADERS`. e.g.
52
+ //
53
+ // #ifndef AT_PER_OPERATOR_HEADERS
54
+ // #include <ATen/Functions.h>
55
+ // #else
56
+ // #include <ATen/ops/sum.h>
57
+ // #endif
58
+
59
+ #include <ATen/Context.h>
60
+ #include <ATen/DeviceGuard.h>
61
+ #include <ATen/TensorUtils.h>
62
+ #include <ATen/TracerMode.h>
63
+ #include <ATen/core/Generator.h>
64
+ #include <ATen/core/Reduction.h>
65
+ #include <c10/core/SymInt.h>
66
+ #include <ATen/core/Tensor.h>
67
+ #include <c10/core/Scalar.h>
68
+ #include <c10/core/Storage.h>
69
+ #include <c10/core/TensorOptions.h>
70
+ #include <c10/util/Deprecated.h>
71
+ #include <c10/util/Optional.h>
72
+ #include <c10/util/OptionalArrayRef.h>
73
+
74
+ #include <ATen/ops/from_blob.h>
75
+ #include <ATen/ops/tensor.h>
76
+
77
+ #include <ATen/ops/_adaptive_avg_pool2d.h>
78
+ #include <ATen/ops/_adaptive_avg_pool2d_backward.h>
79
+ #include <ATen/ops/_adaptive_avg_pool3d.h>
80
+ #include <ATen/ops/_adaptive_avg_pool3d_backward.h>
81
+ #include <ATen/ops/_add_batch_dim.h>
82
+ #include <ATen/ops/_add_relu.h>
83
+ #include <ATen/ops/_addmm_activation.h>
84
+ #include <ATen/ops/_aminmax.h>
85
+ #include <ATen/ops/_amp_foreach_non_finite_check_and_unscale.h>
86
+ #include <ATen/ops/_amp_update_scale.h>
87
+ #include <ATen/ops/_assert_async.h>
88
+ #include <ATen/ops/_assert_tensor_metadata.h>
89
+ #include <ATen/ops/_autocast_to_full_precision.h>
90
+ #include <ATen/ops/_autocast_to_reduced_precision.h>
91
+ #include <ATen/ops/_backward.h>
92
+ #include <ATen/ops/_batch_norm_impl_index.h>
93
+ #include <ATen/ops/_batch_norm_impl_index_backward.h>
94
+ #include <ATen/ops/_cast_Byte.h>
95
+ #include <ATen/ops/_cast_Char.h>
96
+ #include <ATen/ops/_cast_Double.h>
97
+ #include <ATen/ops/_cast_Float.h>
98
+ #include <ATen/ops/_cast_Half.h>
99
+ #include <ATen/ops/_cast_Int.h>
100
+ #include <ATen/ops/_cast_Long.h>
101
+ #include <ATen/ops/_cast_Short.h>
102
+ #include <ATen/ops/_cdist_backward.h>
103
+ #include <ATen/ops/_cdist_forward.h>
104
+ #include <ATen/ops/_cholesky_solve_helper.h>
105
+ #include <ATen/ops/_choose_qparams_per_tensor.h>
106
+ #include <ATen/ops/_coalesce.h>
107
+ #include <ATen/ops/_coalesced.h>
108
+ #include <ATen/ops/_compute_linear_combination.h>
109
+ #include <ATen/ops/_conj.h>
110
+ #include <ATen/ops/_conj_copy.h>
111
+ #include <ATen/ops/_conj_physical.h>
112
+ #include <ATen/ops/_conv_depthwise2d.h>
113
+ #include <ATen/ops/_convert_indices_from_coo_to_csr.h>
114
+ #include <ATen/ops/_convert_indices_from_csr_to_coo.h>
115
+ #include <ATen/ops/_convert_weight_to_int4pack.h>
116
+ #include <ATen/ops/_convolution.h>
117
+ #include <ATen/ops/_convolution_double_backward.h>
118
+ #include <ATen/ops/_convolution_mode.h>
119
+ #include <ATen/ops/_copy_from.h>
120
+ #include <ATen/ops/_copy_from_and_resize.h>
121
+ #include <ATen/ops/_cslt_compress.h>
122
+ #include <ATen/ops/_cslt_sparse_mm.h>
123
+ #include <ATen/ops/_ctc_loss.h>
124
+ #include <ATen/ops/_ctc_loss_backward.h>
125
+ #include <ATen/ops/_cudnn_ctc_loss.h>
126
+ #include <ATen/ops/_cudnn_init_dropout_state.h>
127
+ #include <ATen/ops/_cudnn_rnn.h>
128
+ #include <ATen/ops/_cudnn_rnn_backward.h>
129
+ #include <ATen/ops/_cudnn_rnn_flatten_weight.h>
130
+ #include <ATen/ops/_cufft_clear_plan_cache.h>
131
+ #include <ATen/ops/_cufft_get_plan_cache_max_size.h>
132
+ #include <ATen/ops/_cufft_get_plan_cache_size.h>
133
+ #include <ATen/ops/_cufft_set_plan_cache_max_size.h>
134
+ #include <ATen/ops/_cummax_helper.h>
135
+ #include <ATen/ops/_cummin_helper.h>
136
+ #include <ATen/ops/_debug_has_internal_overlap.h>
137
+ #include <ATen/ops/_dimI.h>
138
+ #include <ATen/ops/_dimV.h>
139
+ #include <ATen/ops/_dim_arange.h>
140
+ #include <ATen/ops/_dirichlet_grad.h>
141
+ #include <ATen/ops/_efficient_attention_backward.h>
142
+ #include <ATen/ops/_efficient_attention_forward.h>
143
+ #include <ATen/ops/_efficientzerotensor.h>
144
+ #include <ATen/ops/_embedding_bag.h>
145
+ #include <ATen/ops/_embedding_bag_backward.h>
146
+ #include <ATen/ops/_embedding_bag_dense_backward.h>
147
+ #include <ATen/ops/_embedding_bag_forward_only.h>
148
+ #include <ATen/ops/_embedding_bag_per_sample_weights_backward.h>
149
+ #include <ATen/ops/_embedding_bag_sparse_backward.h>
150
+ #include <ATen/ops/_empty_affine_quantized.h>
151
+ #include <ATen/ops/_empty_per_channel_affine_quantized.h>
152
+ #include <ATen/ops/_euclidean_dist.h>
153
+ #include <ATen/ops/_fake_quantize_learnable_per_channel_affine.h>
154
+ #include <ATen/ops/_fake_quantize_learnable_per_channel_affine_backward.h>
155
+ #include <ATen/ops/_fake_quantize_learnable_per_tensor_affine.h>
156
+ #include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward.h>
157
+ #include <ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams.h>
158
+ #include <ATen/ops/_fft_c2c.h>
159
+ #include <ATen/ops/_fft_c2r.h>
160
+ #include <ATen/ops/_fft_r2c.h>
161
+ #include <ATen/ops/_fill_mem_eff_dropout_mask.h>
162
+ #include <ATen/ops/_flash_attention_backward.h>
163
+ #include <ATen/ops/_flash_attention_forward.h>
164
+ #include <ATen/ops/_foobar.h>
165
+ #include <ATen/ops/_foreach_abs.h>
166
+ #include <ATen/ops/_foreach_acos.h>
167
+ #include <ATen/ops/_foreach_add.h>
168
+ #include <ATen/ops/_foreach_addcdiv.h>
169
+ #include <ATen/ops/_foreach_addcmul.h>
170
+ #include <ATen/ops/_foreach_asin.h>
171
+ #include <ATen/ops/_foreach_atan.h>
172
+ #include <ATen/ops/_foreach_ceil.h>
173
+ #include <ATen/ops/_foreach_clamp_max.h>
174
+ #include <ATen/ops/_foreach_clamp_min.h>
175
+ #include <ATen/ops/_foreach_copy.h>
176
+ #include <ATen/ops/_foreach_cos.h>
177
+ #include <ATen/ops/_foreach_cosh.h>
178
+ #include <ATen/ops/_foreach_div.h>
179
+ #include <ATen/ops/_foreach_erf.h>
180
+ #include <ATen/ops/_foreach_erfc.h>
181
+ #include <ATen/ops/_foreach_exp.h>
182
+ #include <ATen/ops/_foreach_expm1.h>
183
+ #include <ATen/ops/_foreach_floor.h>
184
+ #include <ATen/ops/_foreach_frac.h>
185
+ #include <ATen/ops/_foreach_lerp.h>
186
+ #include <ATen/ops/_foreach_lgamma.h>
187
+ #include <ATen/ops/_foreach_log.h>
188
+ #include <ATen/ops/_foreach_log10.h>
189
+ #include <ATen/ops/_foreach_log1p.h>
190
+ #include <ATen/ops/_foreach_log2.h>
191
+ #include <ATen/ops/_foreach_maximum.h>
192
+ #include <ATen/ops/_foreach_minimum.h>
193
+ #include <ATen/ops/_foreach_mul.h>
194
+ #include <ATen/ops/_foreach_neg.h>
195
+ #include <ATen/ops/_foreach_norm.h>
196
+ #include <ATen/ops/_foreach_pow.h>
197
+ #include <ATen/ops/_foreach_reciprocal.h>
198
+ #include <ATen/ops/_foreach_round.h>
199
+ #include <ATen/ops/_foreach_sigmoid.h>
200
+ #include <ATen/ops/_foreach_sign.h>
201
+ #include <ATen/ops/_foreach_sin.h>
202
+ #include <ATen/ops/_foreach_sinh.h>
203
+ #include <ATen/ops/_foreach_sqrt.h>
204
+ #include <ATen/ops/_foreach_sub.h>
205
+ #include <ATen/ops/_foreach_tan.h>
206
+ #include <ATen/ops/_foreach_tanh.h>
207
+ #include <ATen/ops/_foreach_trunc.h>
208
+ #include <ATen/ops/_foreach_zero.h>
209
+ #include <ATen/ops/_functional_assert_async.h>
210
+ #include <ATen/ops/_functional_sym_constrain_range.h>
211
+ #include <ATen/ops/_functional_sym_constrain_range_for_size.h>
212
+ #include <ATen/ops/_fused_adam.h>
213
+ #include <ATen/ops/_fused_adamw.h>
214
+ #include <ATen/ops/_fused_dropout.h>
215
+ #include <ATen/ops/_fused_moving_avg_obs_fq_helper.h>
216
+ #include <ATen/ops/_fused_sdp_choice.h>
217
+ #include <ATen/ops/_fw_primal.h>
218
+ #include <ATen/ops/_fw_primal_copy.h>
219
+ #include <ATen/ops/_gather_sparse_backward.h>
220
+ #include <ATen/ops/_grid_sampler_2d_cpu_fallback.h>
221
+ #include <ATen/ops/_grid_sampler_2d_cpu_fallback_backward.h>
222
+ #include <ATen/ops/_has_compatible_shallow_copy_type.h>
223
+ #include <ATen/ops/_has_same_storage_numel.h>
224
+ #include <ATen/ops/_histogramdd_bin_edges.h>
225
+ #include <ATen/ops/_histogramdd_from_bin_cts.h>
226
+ #include <ATen/ops/_histogramdd_from_bin_tensors.h>
227
+ #include <ATen/ops/_index_put_impl.h>
228
+ #include <ATen/ops/_indices.h>
229
+ #include <ATen/ops/_indices_copy.h>
230
+ #include <ATen/ops/_int_mm.h>
231
+ #include <ATen/ops/_is_all_true.h>
232
+ #include <ATen/ops/_is_any_true.h>
233
+ #include <ATen/ops/_is_zerotensor.h>
234
+ #include <ATen/ops/_linalg_check_errors.h>
235
+ #include <ATen/ops/_linalg_det.h>
236
+ #include <ATen/ops/_linalg_eigh.h>
237
+ #include <ATen/ops/_linalg_slogdet.h>
238
+ #include <ATen/ops/_linalg_solve_ex.h>
239
+ #include <ATen/ops/_linalg_svd.h>
240
+ #include <ATen/ops/_local_scalar_dense.h>
241
+ #include <ATen/ops/_log_softmax.h>
242
+ #include <ATen/ops/_log_softmax_backward_data.h>
243
+ #include <ATen/ops/_logcumsumexp.h>
244
+ #include <ATen/ops/_lstm_mps.h>
245
+ #include <ATen/ops/_lu_with_info.h>
246
+ #include <ATen/ops/_make_dep_token.h>
247
+ #include <ATen/ops/_make_dual.h>
248
+ #include <ATen/ops/_make_dual_copy.h>
249
+ #include <ATen/ops/_make_per_channel_quantized_tensor.h>
250
+ #include <ATen/ops/_make_per_tensor_quantized_tensor.h>
251
+ #include <ATen/ops/_masked_scale.h>
252
+ #include <ATen/ops/_masked_softmax.h>
253
+ #include <ATen/ops/_masked_softmax_backward.h>
254
+ #include <ATen/ops/_mixed_dtypes_linear.h>
255
+ #include <ATen/ops/_mkldnn_reshape.h>
256
+ #include <ATen/ops/_mkldnn_transpose.h>
257
+ #include <ATen/ops/_mps_convolution.h>
258
+ #include <ATen/ops/_mps_convolution_transpose.h>
259
+ #include <ATen/ops/_native_batch_norm_legit.h>
260
+ #include <ATen/ops/_native_batch_norm_legit_no_training.h>
261
+ #include <ATen/ops/_native_multi_head_attention.h>
262
+ #include <ATen/ops/_neg_view.h>
263
+ #include <ATen/ops/_neg_view_copy.h>
264
+ #include <ATen/ops/_nested_from_padded.h>
265
+ #include <ATen/ops/_nested_from_padded_and_nested_example.h>
266
+ #include <ATen/ops/_nested_select_backward.h>
267
+ #include <ATen/ops/_nested_sum_backward.h>
268
+ #include <ATen/ops/_nested_tensor_from_mask.h>
269
+ #include <ATen/ops/_nested_tensor_from_mask_left_aligned.h>
270
+ #include <ATen/ops/_nested_tensor_from_tensor_list.h>
271
+ #include <ATen/ops/_nested_tensor_size.h>
272
+ #include <ATen/ops/_nested_tensor_softmax_with_shape.h>
273
+ #include <ATen/ops/_nested_tensor_storage_offsets.h>
274
+ #include <ATen/ops/_nested_tensor_strides.h>
275
+ #include <ATen/ops/_nested_view_from_buffer.h>
276
+ #include <ATen/ops/_nested_view_from_buffer_copy.h>
277
+ #include <ATen/ops/_new_zeros_with_same_feature_meta.h>
278
+ #include <ATen/ops/_nnpack_available.h>
279
+ #include <ATen/ops/_nnpack_spatial_convolution.h>
280
+ #include <ATen/ops/_nnz.h>
281
+ #include <ATen/ops/_pack_padded_sequence.h>
282
+ #include <ATen/ops/_pack_padded_sequence_backward.h>
283
+ #include <ATen/ops/_pad_circular.h>
284
+ #include <ATen/ops/_pad_enum.h>
285
+ #include <ATen/ops/_pad_packed_sequence.h>
286
+ #include <ATen/ops/_pdist_backward.h>
287
+ #include <ATen/ops/_pdist_forward.h>
288
+ #include <ATen/ops/_pin_memory.h>
289
+ #include <ATen/ops/_prelu_kernel.h>
290
+ #include <ATen/ops/_prelu_kernel_backward.h>
291
+ #include <ATen/ops/_propagate_xla_data.h>
292
+ #include <ATen/ops/_remove_batch_dim.h>
293
+ #include <ATen/ops/_reshape_alias.h>
294
+ #include <ATen/ops/_reshape_alias_copy.h>
295
+ #include <ATen/ops/_reshape_copy.h>
296
+ #include <ATen/ops/_reshape_from_tensor.h>
297
+ #include <ATen/ops/_resize_output.h>
298
+ #include <ATen/ops/_rowwise_prune.h>
299
+ #include <ATen/ops/_sample_dirichlet.h>
300
+ #include <ATen/ops/_saturate_weight_to_fp16.h>
301
+ #include <ATen/ops/_scaled_dot_product_attention_math.h>
302
+ #include <ATen/ops/_scaled_dot_product_efficient_attention.h>
303
+ #include <ATen/ops/_scaled_dot_product_efficient_attention_backward.h>
304
+ #include <ATen/ops/_scaled_dot_product_flash_attention.h>
305
+ #include <ATen/ops/_scaled_dot_product_flash_attention_backward.h>
306
+ #include <ATen/ops/_scaled_mm.h>
307
+ #include <ATen/ops/_segment_reduce_backward.h>
308
+ #include <ATen/ops/_shape_as_tensor.h>
309
+ #include <ATen/ops/_slow_conv2d_backward.h>
310
+ #include <ATen/ops/_slow_conv2d_forward.h>
311
+ #include <ATen/ops/_sobol_engine_draw.h>
312
+ #include <ATen/ops/_sobol_engine_ff.h>
313
+ #include <ATen/ops/_sobol_engine_initialize_state.h>
314
+ #include <ATen/ops/_sobol_engine_scramble.h>
315
+ #include <ATen/ops/_softmax.h>
316
+ #include <ATen/ops/_softmax_backward_data.h>
317
+ #include <ATen/ops/_sparse_addmm.h>
318
+ #include <ATen/ops/_sparse_broadcast_to.h>
319
+ #include <ATen/ops/_sparse_broadcast_to_copy.h>
320
+ #include <ATen/ops/_sparse_bsc_tensor_unsafe.h>
321
+ #include <ATen/ops/_sparse_bsr_tensor_unsafe.h>
322
+ #include <ATen/ops/_sparse_compressed_tensor_unsafe.h>
323
+ #include <ATen/ops/_sparse_coo_tensor_unsafe.h>
324
+ #include <ATen/ops/_sparse_coo_tensor_with_dims.h>
325
+ #include <ATen/ops/_sparse_coo_tensor_with_dims_and_tensors.h>
326
+ #include <ATen/ops/_sparse_csc_tensor_unsafe.h>
327
+ #include <ATen/ops/_sparse_csr_prod.h>
328
+ #include <ATen/ops/_sparse_csr_sum.h>
329
+ #include <ATen/ops/_sparse_csr_tensor_unsafe.h>
330
+ #include <ATen/ops/_sparse_log_softmax.h>
331
+ #include <ATen/ops/_sparse_log_softmax_backward_data.h>
332
+ #include <ATen/ops/_sparse_mask_projection.h>
333
+ #include <ATen/ops/_sparse_mm.h>
334
+ #include <ATen/ops/_sparse_mm_reduce_impl.h>
335
+ #include <ATen/ops/_sparse_mm_reduce_impl_backward.h>
336
+ #include <ATen/ops/_sparse_semi_structured_linear.h>
337
+ #include <ATen/ops/_sparse_softmax.h>
338
+ #include <ATen/ops/_sparse_softmax_backward_data.h>
339
+ #include <ATen/ops/_sparse_sparse_matmul.h>
340
+ #include <ATen/ops/_sparse_sum.h>
341
+ #include <ATen/ops/_sparse_sum_backward.h>
342
+ #include <ATen/ops/_spdiags.h>
343
+ #include <ATen/ops/_stack.h>
344
+ #include <ATen/ops/_standard_gamma.h>
345
+ #include <ATen/ops/_standard_gamma_grad.h>
346
+ #include <ATen/ops/_test_ambiguous_defaults.h>
347
+ #include <ATen/ops/_test_autograd_multiple_dispatch.h>
348
+ #include <ATen/ops/_test_autograd_multiple_dispatch_view.h>
349
+ #include <ATen/ops/_test_autograd_multiple_dispatch_view_copy.h>
350
+ #include <ATen/ops/_test_check_tensor.h>
351
+ #include <ATen/ops/_test_functorch_fallback.h>
352
+ #include <ATen/ops/_test_optional_filled_intlist.h>
353
+ #include <ATen/ops/_test_optional_floatlist.h>
354
+ #include <ATen/ops/_test_optional_intlist.h>
355
+ #include <ATen/ops/_test_serialization_subcmul.h>
356
+ #include <ATen/ops/_test_string_default.h>
357
+ #include <ATen/ops/_test_warn_in_autograd.h>
358
+ #include <ATen/ops/_thnn_differentiable_gru_cell_backward.h>
359
+ #include <ATen/ops/_thnn_differentiable_lstm_cell_backward.h>
360
+ #include <ATen/ops/_thnn_fused_gru_cell.h>
361
+ #include <ATen/ops/_thnn_fused_gru_cell_backward.h>
362
+ #include <ATen/ops/_thnn_fused_lstm_cell.h>
363
+ #include <ATen/ops/_thnn_fused_lstm_cell_backward.h>
364
+ #include <ATen/ops/_thnn_fused_lstm_cell_backward_impl.h>
365
+ #include <ATen/ops/_to_copy.h>
366
+ #include <ATen/ops/_to_cpu.h>
367
+ #include <ATen/ops/_to_dense.h>
368
+ #include <ATen/ops/_to_sparse.h>
369
+ #include <ATen/ops/_to_sparse_bsc.h>
370
+ #include <ATen/ops/_to_sparse_bsr.h>
371
+ #include <ATen/ops/_to_sparse_csc.h>
372
+ #include <ATen/ops/_to_sparse_csr.h>
373
+ #include <ATen/ops/_to_sparse_semi_structured.h>
374
+ #include <ATen/ops/_transform_bias_rescale_qkv.h>
375
+ #include <ATen/ops/_transformer_encoder_layer_fwd.h>
376
+ #include <ATen/ops/_trilinear.h>
377
+ #include <ATen/ops/_triton_multi_head_attention.h>
378
+ #include <ATen/ops/_triton_scaled_dot_attention.h>
379
+ #include <ATen/ops/_unique.h>
380
+ #include <ATen/ops/_unique2.h>
381
+ #include <ATen/ops/_unpack_dual.h>
382
+ #include <ATen/ops/_unsafe_index.h>
383
+ #include <ATen/ops/_unsafe_index_put.h>
384
+ #include <ATen/ops/_unsafe_view.h>
385
+ #include <ATen/ops/_upsample_bicubic2d_aa.h>
386
+ #include <ATen/ops/_upsample_bicubic2d_aa_backward.h>
387
+ #include <ATen/ops/_upsample_bilinear2d_aa.h>
388
+ #include <ATen/ops/_upsample_bilinear2d_aa_backward.h>
389
+ #include <ATen/ops/_upsample_nearest_exact1d.h>
390
+ #include <ATen/ops/_upsample_nearest_exact1d_backward.h>
391
+ #include <ATen/ops/_upsample_nearest_exact2d.h>
392
+ #include <ATen/ops/_upsample_nearest_exact2d_backward.h>
393
+ #include <ATen/ops/_upsample_nearest_exact3d.h>
394
+ #include <ATen/ops/_upsample_nearest_exact3d_backward.h>
395
+ #include <ATen/ops/_use_cudnn_ctc_loss.h>
396
+ #include <ATen/ops/_use_cudnn_rnn_flatten_weight.h>
397
+ #include <ATen/ops/_validate_compressed_sparse_indices.h>
398
+ #include <ATen/ops/_validate_sparse_bsc_tensor_args.h>
399
+ #include <ATen/ops/_validate_sparse_bsr_tensor_args.h>
400
+ #include <ATen/ops/_validate_sparse_compressed_tensor_args.h>
401
+ #include <ATen/ops/_validate_sparse_coo_tensor_args.h>
402
+ #include <ATen/ops/_validate_sparse_csc_tensor_args.h>
403
+ #include <ATen/ops/_validate_sparse_csr_tensor_args.h>
404
+ #include <ATen/ops/_values.h>
405
+ #include <ATen/ops/_values_copy.h>
406
+ #include <ATen/ops/_version.h>
407
+ #include <ATen/ops/_weight_int4pack_mm.h>
408
+ #include <ATen/ops/_weight_norm.h>
409
+ #include <ATen/ops/_weight_norm_differentiable_backward.h>
410
+ #include <ATen/ops/_weight_norm_interface.h>
411
+ #include <ATen/ops/_weight_norm_interface_backward.h>
412
+ #include <ATen/ops/abs.h>
413
+ #include <ATen/ops/absolute.h>
414
+ #include <ATen/ops/acos.h>
415
+ #include <ATen/ops/acosh.h>
416
+ #include <ATen/ops/adaptive_avg_pool1d.h>
417
+ #include <ATen/ops/adaptive_avg_pool2d.h>
418
+ #include <ATen/ops/adaptive_avg_pool3d.h>
419
+ #include <ATen/ops/adaptive_avg_pool3d_backward.h>
420
+ #include <ATen/ops/adaptive_max_pool1d.h>
421
+ #include <ATen/ops/adaptive_max_pool2d.h>
422
+ #include <ATen/ops/adaptive_max_pool2d_backward.h>
423
+ #include <ATen/ops/adaptive_max_pool3d.h>
424
+ #include <ATen/ops/adaptive_max_pool3d_backward.h>
425
+ #include <ATen/ops/add.h>
426
+ #include <ATen/ops/addbmm.h>
427
+ #include <ATen/ops/addcdiv.h>
428
+ #include <ATen/ops/addcmul.h>
429
+ #include <ATen/ops/addmm.h>
430
+ #include <ATen/ops/addmv.h>
431
+ #include <ATen/ops/addr.h>
432
+ #include <ATen/ops/adjoint.h>
433
+ #include <ATen/ops/affine_grid_generator.h>
434
+ #include <ATen/ops/affine_grid_generator_backward.h>
435
+ #include <ATen/ops/alias.h>
436
+ #include <ATen/ops/alias_copy.h>
437
+ #include <ATen/ops/align_as.h>
438
+ #include <ATen/ops/align_tensors.h>
439
+ #include <ATen/ops/align_to.h>
440
+ #include <ATen/ops/all.h>
441
+ #include <ATen/ops/allclose.h>
442
+ #include <ATen/ops/alpha_dropout.h>
443
+ #include <ATen/ops/amax.h>
444
+ #include <ATen/ops/amin.h>
445
+ #include <ATen/ops/aminmax.h>
446
+ #include <ATen/ops/and.h>
447
+ #include <ATen/ops/angle.h>
448
+ #include <ATen/ops/any.h>
449
+ #include <ATen/ops/arange.h>
450
+ #include <ATen/ops/arccos.h>
451
+ #include <ATen/ops/arccosh.h>
452
+ #include <ATen/ops/arcsin.h>
453
+ #include <ATen/ops/arcsinh.h>
454
+ #include <ATen/ops/arctan.h>
455
+ #include <ATen/ops/arctan2.h>
456
+ #include <ATen/ops/arctanh.h>
457
+ #include <ATen/ops/argmax.h>
458
+ #include <ATen/ops/argmin.h>
459
+ #include <ATen/ops/argsort.h>
460
+ #include <ATen/ops/argwhere.h>
461
+ #include <ATen/ops/as_strided.h>
462
+ #include <ATen/ops/as_strided_copy.h>
463
+ #include <ATen/ops/as_strided_scatter.h>
464
+ #include <ATen/ops/asin.h>
465
+ #include <ATen/ops/asinh.h>
466
+ #include <ATen/ops/atan.h>
467
+ #include <ATen/ops/atan2.h>
468
+ #include <ATen/ops/atanh.h>
469
+ #include <ATen/ops/atleast_1d.h>
470
+ #include <ATen/ops/atleast_2d.h>
471
+ #include <ATen/ops/atleast_3d.h>
472
+ #include <ATen/ops/avg_pool1d.h>
473
+ #include <ATen/ops/avg_pool2d.h>
474
+ #include <ATen/ops/avg_pool2d_backward.h>
475
+ #include <ATen/ops/avg_pool3d.h>
476
+ #include <ATen/ops/avg_pool3d_backward.h>
477
+ #include <ATen/ops/baddbmm.h>
478
+ #include <ATen/ops/bartlett_window.h>
479
+ #include <ATen/ops/batch_norm.h>
480
+ #include <ATen/ops/batch_norm_backward_elemt.h>
481
+ #include <ATen/ops/batch_norm_backward_reduce.h>
482
+ #include <ATen/ops/batch_norm_elemt.h>
483
+ #include <ATen/ops/batch_norm_gather_stats.h>
484
+ #include <ATen/ops/batch_norm_gather_stats_with_counts.h>
485
+ #include <ATen/ops/batch_norm_stats.h>
486
+ #include <ATen/ops/batch_norm_update_stats.h>
487
+ #include <ATen/ops/bernoulli.h>
488
+ #include <ATen/ops/bilinear.h>
489
+ #include <ATen/ops/binary_cross_entropy.h>
490
+ #include <ATen/ops/binary_cross_entropy_backward.h>
491
+ #include <ATen/ops/binary_cross_entropy_with_logits.h>
492
+ #include <ATen/ops/bincount.h>
493
+ #include <ATen/ops/binomial.h>
494
+ #include <ATen/ops/bitwise_and.h>
495
+ #include <ATen/ops/bitwise_left_shift.h>
496
+ #include <ATen/ops/bitwise_not.h>
497
+ #include <ATen/ops/bitwise_or.h>
498
+ #include <ATen/ops/bitwise_right_shift.h>
499
+ #include <ATen/ops/bitwise_xor.h>
500
+ #include <ATen/ops/blackman_window.h>
501
+ #include <ATen/ops/block_diag.h>
502
+ #include <ATen/ops/bmm.h>
503
+ #include <ATen/ops/broadcast_tensors.h>
504
+ #include <ATen/ops/broadcast_to.h>
505
+ #include <ATen/ops/bucketize.h>
506
+ #include <ATen/ops/can_cast.h>
507
+ #include <ATen/ops/cartesian_prod.h>
508
+ #include <ATen/ops/cat.h>
509
+ #include <ATen/ops/cauchy.h>
510
+ #include <ATen/ops/ccol_indices.h>
511
+ #include <ATen/ops/ccol_indices_copy.h>
512
+ #include <ATen/ops/cdist.h>
513
+ #include <ATen/ops/ceil.h>
514
+ #include <ATen/ops/celu.h>
515
+ #include <ATen/ops/chain_matmul.h>
516
+ #include <ATen/ops/chalf.h>
517
+ #include <ATen/ops/channel_shuffle.h>
518
+ #include <ATen/ops/cholesky.h>
519
+ #include <ATen/ops/cholesky_inverse.h>
520
+ #include <ATen/ops/cholesky_solve.h>
521
+ #include <ATen/ops/choose_qparams_optimized.h>
522
+ #include <ATen/ops/chunk.h>
523
+ #include <ATen/ops/clamp.h>
524
+ #include <ATen/ops/clamp_max.h>
525
+ #include <ATen/ops/clamp_min.h>
526
+ #include <ATen/ops/clip.h>
527
+ #include <ATen/ops/clone.h>
528
+ #include <ATen/ops/coalesce.h>
529
+ #include <ATen/ops/col2im.h>
530
+ #include <ATen/ops/col_indices.h>
531
+ #include <ATen/ops/col_indices_copy.h>
532
+ #include <ATen/ops/column_stack.h>
533
+ #include <ATen/ops/combinations.h>
534
+ #include <ATen/ops/complex.h>
535
+ #include <ATen/ops/concat.h>
536
+ #include <ATen/ops/concatenate.h>
537
+ #include <ATen/ops/conj.h>
538
+ #include <ATen/ops/conj_physical.h>
539
+ #include <ATen/ops/constant_pad_nd.h>
540
+ #include <ATen/ops/contiguous.h>
541
+ #include <ATen/ops/conv1d.h>
542
+ #include <ATen/ops/conv2d.h>
543
+ #include <ATen/ops/conv3d.h>
544
+ #include <ATen/ops/conv_depthwise3d.h>
545
+ #include <ATen/ops/conv_tbc.h>
546
+ #include <ATen/ops/conv_tbc_backward.h>
547
+ #include <ATen/ops/conv_transpose1d.h>
548
+ #include <ATen/ops/conv_transpose2d.h>
549
+ #include <ATen/ops/conv_transpose3d.h>
550
+ #include <ATen/ops/convolution.h>
551
+ #include <ATen/ops/convolution_backward.h>
552
+ #include <ATen/ops/convolution_backward_overrideable.h>
553
+ #include <ATen/ops/convolution_overrideable.h>
554
+ #include <ATen/ops/copy.h>
555
+ #include <ATen/ops/copy_sparse_to_sparse.h>
556
+ #include <ATen/ops/copysign.h>
557
+ #include <ATen/ops/corrcoef.h>
558
+ #include <ATen/ops/cos.h>
559
+ #include <ATen/ops/cosh.h>
560
+ #include <ATen/ops/cosine_embedding_loss.h>
561
+ #include <ATen/ops/cosine_similarity.h>
562
+ #include <ATen/ops/count_nonzero.h>
563
+ #include <ATen/ops/cov.h>
564
+ #include <ATen/ops/cross.h>
565
+ #include <ATen/ops/cross_entropy_loss.h>
566
+ #include <ATen/ops/crow_indices.h>
567
+ #include <ATen/ops/crow_indices_copy.h>
568
+ #include <ATen/ops/ctc_loss.h>
569
+ #include <ATen/ops/cudnn_affine_grid_generator.h>
570
+ #include <ATen/ops/cudnn_affine_grid_generator_backward.h>
571
+ #include <ATen/ops/cudnn_batch_norm.h>
572
+ #include <ATen/ops/cudnn_batch_norm_backward.h>
573
+ #include <ATen/ops/cudnn_convolution.h>
574
+ #include <ATen/ops/cudnn_convolution_add_relu.h>
575
+ #include <ATen/ops/cudnn_convolution_relu.h>
576
+ #include <ATen/ops/cudnn_convolution_transpose.h>
577
+ #include <ATen/ops/cudnn_grid_sampler.h>
578
+ #include <ATen/ops/cudnn_grid_sampler_backward.h>
579
+ #include <ATen/ops/cudnn_is_acceptable.h>
580
+ #include <ATen/ops/cummax.h>
581
+ #include <ATen/ops/cummaxmin_backward.h>
582
+ #include <ATen/ops/cummin.h>
583
+ #include <ATen/ops/cumprod.h>
584
+ #include <ATen/ops/cumprod_backward.h>
585
+ #include <ATen/ops/cumsum.h>
586
+ #include <ATen/ops/cumulative_trapezoid.h>
587
+ #include <ATen/ops/data.h>
588
+ #include <ATen/ops/deg2rad.h>
589
+ #include <ATen/ops/dense_dim.h>
590
+ #include <ATen/ops/dequantize.h>
591
+ #include <ATen/ops/det.h>
592
+ #include <ATen/ops/detach.h>
593
+ #include <ATen/ops/detach_copy.h>
594
+ #include <ATen/ops/diag.h>
595
+ #include <ATen/ops/diag_embed.h>
596
+ #include <ATen/ops/diagflat.h>
597
+ #include <ATen/ops/diagonal.h>
598
+ #include <ATen/ops/diagonal_backward.h>
599
+ #include <ATen/ops/diagonal_copy.h>
600
+ #include <ATen/ops/diagonal_scatter.h>
601
+ #include <ATen/ops/diff.h>
602
+ #include <ATen/ops/digamma.h>
603
+ #include <ATen/ops/dist.h>
604
+ #include <ATen/ops/div.h>
605
+ #include <ATen/ops/divide.h>
606
+ #include <ATen/ops/dot.h>
607
+ #include <ATen/ops/dropout.h>
608
+ #include <ATen/ops/dsplit.h>
609
+ #include <ATen/ops/dstack.h>
610
+ #include <ATen/ops/einsum.h>
611
+ #include <ATen/ops/elu.h>
612
+ #include <ATen/ops/elu_backward.h>
613
+ #include <ATen/ops/embedding.h>
614
+ #include <ATen/ops/embedding_backward.h>
615
+ #include <ATen/ops/embedding_bag.h>
616
+ #include <ATen/ops/embedding_dense_backward.h>
617
+ #include <ATen/ops/embedding_renorm.h>
618
+ #include <ATen/ops/embedding_sparse_backward.h>
619
+ #include <ATen/ops/empty.h>
620
+ #include <ATen/ops/empty_like.h>
621
+ #include <ATen/ops/empty_permuted.h>
622
+ #include <ATen/ops/empty_quantized.h>
623
+ #include <ATen/ops/empty_strided.h>
624
+ #include <ATen/ops/eq.h>
625
+ #include <ATen/ops/equal.h>
626
+ #include <ATen/ops/erf.h>
627
+ #include <ATen/ops/erfc.h>
628
+ #include <ATen/ops/erfinv.h>
629
+ #include <ATen/ops/exp.h>
630
+ #include <ATen/ops/exp2.h>
631
+ #include <ATen/ops/expand.h>
632
+ #include <ATen/ops/expand_as.h>
633
+ #include <ATen/ops/expand_copy.h>
634
+ #include <ATen/ops/expm1.h>
635
+ #include <ATen/ops/exponential.h>
636
+ #include <ATen/ops/eye.h>
637
+ #include <ATen/ops/fake_quantize_per_channel_affine.h>
638
+ #include <ATen/ops/fake_quantize_per_channel_affine_cachemask.h>
639
+ #include <ATen/ops/fake_quantize_per_channel_affine_cachemask_backward.h>
640
+ #include <ATen/ops/fake_quantize_per_tensor_affine.h>
641
+ #include <ATen/ops/fake_quantize_per_tensor_affine_cachemask.h>
642
+ #include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward.h>
643
+ #include <ATen/ops/fbgemm_linear_fp16_weight.h>
644
+ #include <ATen/ops/fbgemm_linear_fp16_weight_fp32_activation.h>
645
+ #include <ATen/ops/fbgemm_linear_int8_weight.h>
646
+ #include <ATen/ops/fbgemm_linear_int8_weight_fp32_activation.h>
647
+ #include <ATen/ops/fbgemm_linear_quantize_weight.h>
648
+ #include <ATen/ops/fbgemm_pack_gemm_matrix_fp16.h>
649
+ #include <ATen/ops/fbgemm_pack_quantized_matrix.h>
650
+ #include <ATen/ops/feature_alpha_dropout.h>
651
+ #include <ATen/ops/feature_dropout.h>
652
+ #include <ATen/ops/fft_fft.h>
653
+ #include <ATen/ops/fft_fft2.h>
654
+ #include <ATen/ops/fft_fftfreq.h>
655
+ #include <ATen/ops/fft_fftn.h>
656
+ #include <ATen/ops/fft_fftshift.h>
657
+ #include <ATen/ops/fft_hfft.h>
658
+ #include <ATen/ops/fft_hfft2.h>
659
+ #include <ATen/ops/fft_hfftn.h>
660
+ #include <ATen/ops/fft_ifft.h>
661
+ #include <ATen/ops/fft_ifft2.h>
662
+ #include <ATen/ops/fft_ifftn.h>
663
+ #include <ATen/ops/fft_ifftshift.h>
664
+ #include <ATen/ops/fft_ihfft.h>
665
+ #include <ATen/ops/fft_ihfft2.h>
666
+ #include <ATen/ops/fft_ihfftn.h>
667
+ #include <ATen/ops/fft_irfft.h>
668
+ #include <ATen/ops/fft_irfft2.h>
669
+ #include <ATen/ops/fft_irfftn.h>
670
+ #include <ATen/ops/fft_rfft.h>
671
+ #include <ATen/ops/fft_rfft2.h>
672
+ #include <ATen/ops/fft_rfftfreq.h>
673
+ #include <ATen/ops/fft_rfftn.h>
674
+ #include <ATen/ops/fill.h>
675
+ #include <ATen/ops/fill_diagonal.h>
676
+ #include <ATen/ops/fix.h>
677
+ #include <ATen/ops/flatten.h>
678
+ #include <ATen/ops/flatten_dense_tensors.h>
679
+ #include <ATen/ops/flip.h>
680
+ #include <ATen/ops/fliplr.h>
681
+ #include <ATen/ops/flipud.h>
682
+ #include <ATen/ops/float_power.h>
683
+ #include <ATen/ops/floor.h>
684
+ #include <ATen/ops/floor_divide.h>
685
+ #include <ATen/ops/fmax.h>
686
+ #include <ATen/ops/fmin.h>
687
+ #include <ATen/ops/fmod.h>
688
+ #include <ATen/ops/frac.h>
689
+ #include <ATen/ops/fractional_max_pool2d.h>
690
+ #include <ATen/ops/fractional_max_pool2d_backward.h>
691
+ #include <ATen/ops/fractional_max_pool3d.h>
692
+ #include <ATen/ops/fractional_max_pool3d_backward.h>
693
+ #include <ATen/ops/frexp.h>
694
+ #include <ATen/ops/frobenius_norm.h>
695
+ #include <ATen/ops/from_file.h>
696
+ #include <ATen/ops/full.h>
697
+ #include <ATen/ops/full_like.h>
698
+ #include <ATen/ops/fused_moving_avg_obs_fake_quant.h>
699
+ #include <ATen/ops/gather.h>
700
+ #include <ATen/ops/gather_backward.h>
701
+ #include <ATen/ops/gcd.h>
702
+ #include <ATen/ops/ge.h>
703
+ #include <ATen/ops/gelu.h>
704
+ #include <ATen/ops/gelu_backward.h>
705
+ #include <ATen/ops/geometric.h>
706
+ #include <ATen/ops/geqrf.h>
707
+ #include <ATen/ops/ger.h>
708
+ #include <ATen/ops/glu.h>
709
+ #include <ATen/ops/glu_backward.h>
710
+ #include <ATen/ops/glu_backward_jvp.h>
711
+ #include <ATen/ops/glu_jvp.h>
712
+ #include <ATen/ops/gradient.h>
713
+ #include <ATen/ops/greater.h>
714
+ #include <ATen/ops/greater_equal.h>
715
+ #include <ATen/ops/grid_sampler.h>
716
+ #include <ATen/ops/grid_sampler_2d.h>
717
+ #include <ATen/ops/grid_sampler_2d_backward.h>
718
+ #include <ATen/ops/grid_sampler_3d.h>
719
+ #include <ATen/ops/grid_sampler_3d_backward.h>
720
+ #include <ATen/ops/group_norm.h>
721
+ #include <ATen/ops/gru.h>
722
+ #include <ATen/ops/gru_cell.h>
723
+ #include <ATen/ops/gt.h>
724
+ #include <ATen/ops/hamming_window.h>
725
+ #include <ATen/ops/hann_window.h>
726
+ #include <ATen/ops/hardshrink.h>
727
+ #include <ATen/ops/hardshrink_backward.h>
728
+ #include <ATen/ops/hardsigmoid.h>
729
+ #include <ATen/ops/hardsigmoid_backward.h>
730
+ #include <ATen/ops/hardswish.h>
731
+ #include <ATen/ops/hardswish_backward.h>
732
+ #include <ATen/ops/hardtanh.h>
733
+ #include <ATen/ops/hardtanh_backward.h>
734
+ #include <ATen/ops/heaviside.h>
735
+ #include <ATen/ops/hinge_embedding_loss.h>
736
+ #include <ATen/ops/histc.h>
737
+ #include <ATen/ops/histogram.h>
738
+ #include <ATen/ops/histogramdd.h>
739
+ #include <ATen/ops/hsplit.h>
740
+ #include <ATen/ops/hspmm.h>
741
+ #include <ATen/ops/hstack.h>
742
+ #include <ATen/ops/huber_loss.h>
743
+ #include <ATen/ops/huber_loss_backward.h>
744
+ #include <ATen/ops/hypot.h>
745
+ #include <ATen/ops/i0.h>
746
+ #include <ATen/ops/igamma.h>
747
+ #include <ATen/ops/igammac.h>
748
+ #include <ATen/ops/im2col.h>
749
+ #include <ATen/ops/imag.h>
750
+ #include <ATen/ops/index.h>
751
+ #include <ATen/ops/index_add.h>
752
+ #include <ATen/ops/index_copy.h>
753
+ #include <ATen/ops/index_fill.h>
754
+ #include <ATen/ops/index_put.h>
755
+ #include <ATen/ops/index_reduce.h>
756
+ #include <ATen/ops/index_select.h>
757
+ #include <ATen/ops/index_select_backward.h>
758
+ #include <ATen/ops/indices.h>
759
+ #include <ATen/ops/indices_copy.h>
760
+ #include <ATen/ops/infinitely_differentiable_gelu_backward.h>
761
+ #include <ATen/ops/inner.h>
762
+ #include <ATen/ops/instance_norm.h>
763
+ #include <ATen/ops/int_repr.h>
764
+ #include <ATen/ops/inverse.h>
765
+ #include <ATen/ops/is_coalesced.h>
766
+ #include <ATen/ops/is_complex.h>
767
+ #include <ATen/ops/is_conj.h>
768
+ #include <ATen/ops/is_distributed.h>
769
+ #include <ATen/ops/is_floating_point.h>
770
+ #include <ATen/ops/is_inference.h>
771
+ #include <ATen/ops/is_leaf.h>
772
+ #include <ATen/ops/is_neg.h>
773
+ #include <ATen/ops/is_nonzero.h>
774
+ #include <ATen/ops/is_pinned.h>
775
+ #include <ATen/ops/is_same_size.h>
776
+ #include <ATen/ops/is_set_to.h>
777
+ #include <ATen/ops/is_signed.h>
778
+ #include <ATen/ops/is_vulkan_available.h>
779
+ #include <ATen/ops/isclose.h>
780
+ #include <ATen/ops/isfinite.h>
781
+ #include <ATen/ops/isin.h>
782
+ #include <ATen/ops/isinf.h>
783
+ #include <ATen/ops/isnan.h>
784
+ #include <ATen/ops/isneginf.h>
785
+ #include <ATen/ops/isposinf.h>
786
+ #include <ATen/ops/isreal.h>
787
+ #include <ATen/ops/istft.h>
788
+ #include <ATen/ops/item.h>
789
+ #include <ATen/ops/kaiser_window.h>
790
+ #include <ATen/ops/kl_div.h>
791
+ #include <ATen/ops/kron.h>
792
+ #include <ATen/ops/kthvalue.h>
793
+ #include <ATen/ops/l1_loss.h>
794
+ #include <ATen/ops/layer_norm.h>
795
+ #include <ATen/ops/lcm.h>
796
+ #include <ATen/ops/ldexp.h>
797
+ #include <ATen/ops/le.h>
798
+ #include <ATen/ops/leaky_relu.h>
799
+ #include <ATen/ops/leaky_relu_backward.h>
800
+ #include <ATen/ops/lerp.h>
801
+ #include <ATen/ops/less.h>
802
+ #include <ATen/ops/less_equal.h>
803
+ #include <ATen/ops/lgamma.h>
804
+ #include <ATen/ops/lift.h>
805
+ #include <ATen/ops/lift_fresh.h>
806
+ #include <ATen/ops/lift_fresh_copy.h>
807
+ #include <ATen/ops/linalg_cholesky.h>
808
+ #include <ATen/ops/linalg_cholesky_ex.h>
809
+ #include <ATen/ops/linalg_cond.h>
810
+ #include <ATen/ops/linalg_cross.h>
811
+ #include <ATen/ops/linalg_det.h>
812
+ #include <ATen/ops/linalg_diagonal.h>
813
+ #include <ATen/ops/linalg_eig.h>
814
+ #include <ATen/ops/linalg_eigh.h>
815
+ #include <ATen/ops/linalg_eigvals.h>
816
+ #include <ATen/ops/linalg_eigvalsh.h>
817
+ #include <ATen/ops/linalg_householder_product.h>
818
+ #include <ATen/ops/linalg_inv.h>
819
+ #include <ATen/ops/linalg_inv_ex.h>
820
+ #include <ATen/ops/linalg_ldl_factor.h>
821
+ #include <ATen/ops/linalg_ldl_factor_ex.h>
822
+ #include <ATen/ops/linalg_ldl_solve.h>
823
+ #include <ATen/ops/linalg_lstsq.h>
824
+ #include <ATen/ops/linalg_lu.h>
825
+ #include <ATen/ops/linalg_lu_factor.h>
826
+ #include <ATen/ops/linalg_lu_factor_ex.h>
827
+ #include <ATen/ops/linalg_lu_solve.h>
828
+ #include <ATen/ops/linalg_matmul.h>
829
+ #include <ATen/ops/linalg_matrix_exp.h>
830
+ #include <ATen/ops/linalg_matrix_norm.h>
831
+ #include <ATen/ops/linalg_matrix_power.h>
832
+ #include <ATen/ops/linalg_matrix_rank.h>
833
+ #include <ATen/ops/linalg_multi_dot.h>
834
+ #include <ATen/ops/linalg_norm.h>
835
+ #include <ATen/ops/linalg_pinv.h>
836
+ #include <ATen/ops/linalg_qr.h>
837
+ #include <ATen/ops/linalg_slogdet.h>
838
+ #include <ATen/ops/linalg_solve.h>
839
+ #include <ATen/ops/linalg_solve_ex.h>
840
+ #include <ATen/ops/linalg_solve_triangular.h>
841
+ #include <ATen/ops/linalg_svd.h>
842
+ #include <ATen/ops/linalg_svdvals.h>
843
+ #include <ATen/ops/linalg_tensorinv.h>
844
+ #include <ATen/ops/linalg_tensorsolve.h>
845
+ #include <ATen/ops/linalg_vander.h>
846
+ #include <ATen/ops/linalg_vecdot.h>
847
+ #include <ATen/ops/linalg_vector_norm.h>
848
+ #include <ATen/ops/linear.h>
849
+ #include <ATen/ops/linear_backward.h>
850
+ #include <ATen/ops/linspace.h>
851
+ #include <ATen/ops/log.h>
852
+ #include <ATen/ops/log10.h>
853
+ #include <ATen/ops/log1p.h>
854
+ #include <ATen/ops/log2.h>
855
+ #include <ATen/ops/log_normal.h>
856
+ #include <ATen/ops/log_sigmoid.h>
857
+ #include <ATen/ops/log_sigmoid_backward.h>
858
+ #include <ATen/ops/log_sigmoid_forward.h>
859
+ #include <ATen/ops/log_softmax.h>
860
+ #include <ATen/ops/logaddexp.h>
861
+ #include <ATen/ops/logaddexp2.h>
862
+ #include <ATen/ops/logcumsumexp.h>
863
+ #include <ATen/ops/logdet.h>
864
+ #include <ATen/ops/logical_and.h>
865
+ #include <ATen/ops/logical_not.h>
866
+ #include <ATen/ops/logical_or.h>
867
+ #include <ATen/ops/logical_xor.h>
868
+ #include <ATen/ops/logit.h>
869
+ #include <ATen/ops/logit_backward.h>
870
+ #include <ATen/ops/logspace.h>
871
+ #include <ATen/ops/logsumexp.h>
872
+ #include <ATen/ops/lshift.h>
873
+ #include <ATen/ops/lstm.h>
874
+ #include <ATen/ops/lstm_cell.h>
875
+ #include <ATen/ops/lstm_mps_backward.h>
876
+ #include <ATen/ops/lt.h>
877
+ #include <ATen/ops/lu_solve.h>
878
+ #include <ATen/ops/lu_unpack.h>
879
+ #include <ATen/ops/mH.h>
880
+ #include <ATen/ops/mT.h>
881
+ #include <ATen/ops/margin_ranking_loss.h>
882
+ #include <ATen/ops/masked_fill.h>
883
+ #include <ATen/ops/masked_scatter.h>
884
+ #include <ATen/ops/masked_scatter_backward.h>
885
+ #include <ATen/ops/masked_select.h>
886
+ #include <ATen/ops/masked_select_backward.h>
887
+ #include <ATen/ops/matmul.h>
888
+ #include <ATen/ops/matmul_backward.h>
889
+ #include <ATen/ops/matrix_H.h>
890
+ #include <ATen/ops/matrix_exp.h>
891
+ #include <ATen/ops/matrix_exp_backward.h>
892
+ #include <ATen/ops/matrix_power.h>
893
+ #include <ATen/ops/max.h>
894
+ #include <ATen/ops/max_pool1d.h>
895
+ #include <ATen/ops/max_pool1d_with_indices.h>
896
+ #include <ATen/ops/max_pool2d.h>
897
+ #include <ATen/ops/max_pool2d_backward.h>
898
+ #include <ATen/ops/max_pool2d_with_indices.h>
899
+ #include <ATen/ops/max_pool2d_with_indices_backward.h>
900
+ #include <ATen/ops/max_pool3d.h>
901
+ #include <ATen/ops/max_pool3d_with_indices.h>
902
+ #include <ATen/ops/max_pool3d_with_indices_backward.h>
903
+ #include <ATen/ops/max_unpool2d.h>
904
+ #include <ATen/ops/max_unpool3d.h>
905
+ #include <ATen/ops/maximum.h>
906
+ #include <ATen/ops/mean.h>
907
+ #include <ATen/ops/median.h>
908
+ #include <ATen/ops/meshgrid.h>
909
+ #include <ATen/ops/min.h>
910
+ #include <ATen/ops/minimum.h>
911
+ #include <ATen/ops/miopen_batch_norm.h>
912
+ #include <ATen/ops/miopen_batch_norm_backward.h>
913
+ #include <ATen/ops/miopen_convolution.h>
914
+ #include <ATen/ops/miopen_convolution_add_relu.h>
915
+ #include <ATen/ops/miopen_convolution_relu.h>
916
+ #include <ATen/ops/miopen_convolution_transpose.h>
917
+ #include <ATen/ops/miopen_depthwise_convolution.h>
918
+ #include <ATen/ops/miopen_rnn.h>
919
+ #include <ATen/ops/miopen_rnn_backward.h>
920
+ #include <ATen/ops/mish.h>
921
+ #include <ATen/ops/mish_backward.h>
922
+ #include <ATen/ops/mkldnn_adaptive_avg_pool2d.h>
923
+ #include <ATen/ops/mkldnn_adaptive_avg_pool2d_backward.h>
924
+ #include <ATen/ops/mkldnn_convolution.h>
925
+ #include <ATen/ops/mkldnn_linear.h>
926
+ #include <ATen/ops/mkldnn_linear_backward.h>
927
+ #include <ATen/ops/mkldnn_linear_backward_input.h>
928
+ #include <ATen/ops/mkldnn_linear_backward_weights.h>
929
+ #include <ATen/ops/mkldnn_max_pool2d.h>
930
+ #include <ATen/ops/mkldnn_max_pool2d_backward.h>
931
+ #include <ATen/ops/mkldnn_max_pool3d.h>
932
+ #include <ATen/ops/mkldnn_max_pool3d_backward.h>
933
+ #include <ATen/ops/mkldnn_reorder_conv2d_weight.h>
934
+ #include <ATen/ops/mkldnn_reorder_conv3d_weight.h>
935
+ #include <ATen/ops/mkldnn_rnn_layer.h>
936
+ #include <ATen/ops/mkldnn_rnn_layer_backward.h>
937
+ #include <ATen/ops/mm.h>
938
+ #include <ATen/ops/mode.h>
939
+ #include <ATen/ops/moveaxis.h>
940
+ #include <ATen/ops/movedim.h>
941
+ #include <ATen/ops/mps_convolution_backward.h>
942
+ #include <ATen/ops/mps_convolution_transpose_backward.h>
943
+ #include <ATen/ops/mse_loss.h>
944
+ #include <ATen/ops/mse_loss_backward.h>
945
+ #include <ATen/ops/msort.h>
946
+ #include <ATen/ops/mul.h>
947
+ #include <ATen/ops/multi_margin_loss.h>
948
+ #include <ATen/ops/multi_margin_loss_backward.h>
949
+ #include <ATen/ops/multilabel_margin_loss.h>
950
+ #include <ATen/ops/multilabel_margin_loss_backward.h>
951
+ #include <ATen/ops/multilabel_margin_loss_forward.h>
952
+ #include <ATen/ops/multinomial.h>
953
+ #include <ATen/ops/multiply.h>
954
+ #include <ATen/ops/mv.h>
955
+ #include <ATen/ops/mvlgamma.h>
956
+ #include <ATen/ops/nan_to_num.h>
957
+ #include <ATen/ops/nanmean.h>
958
+ #include <ATen/ops/nanmedian.h>
959
+ #include <ATen/ops/nanquantile.h>
960
+ #include <ATen/ops/nansum.h>
961
+ #include <ATen/ops/narrow.h>
962
+ #include <ATen/ops/narrow_copy.h>
963
+ #include <ATen/ops/native_batch_norm.h>
964
+ #include <ATen/ops/native_batch_norm_backward.h>
965
+ #include <ATen/ops/native_channel_shuffle.h>
966
+ #include <ATen/ops/native_dropout.h>
967
+ #include <ATen/ops/native_dropout_backward.h>
968
+ #include <ATen/ops/native_group_norm.h>
969
+ #include <ATen/ops/native_group_norm_backward.h>
970
+ #include <ATen/ops/native_layer_norm.h>
971
+ #include <ATen/ops/native_layer_norm_backward.h>
972
+ #include <ATen/ops/native_norm.h>
973
+ #include <ATen/ops/ne.h>
974
+ #include <ATen/ops/neg.h>
975
+ #include <ATen/ops/negative.h>
976
+ #include <ATen/ops/nested_to_padded_tensor.h>
977
+ #include <ATen/ops/new_empty.h>
978
+ #include <ATen/ops/new_empty_strided.h>
979
+ #include <ATen/ops/new_full.h>
980
+ #include <ATen/ops/new_ones.h>
981
+ #include <ATen/ops/new_zeros.h>
982
+ #include <ATen/ops/nextafter.h>
983
+ #include <ATen/ops/nll_loss.h>
984
+ #include <ATen/ops/nll_loss2d.h>
985
+ #include <ATen/ops/nll_loss2d_backward.h>
986
+ #include <ATen/ops/nll_loss2d_forward.h>
987
+ #include <ATen/ops/nll_loss_backward.h>
988
+ #include <ATen/ops/nll_loss_forward.h>
989
+ #include <ATen/ops/nll_loss_nd.h>
990
+ #include <ATen/ops/nonzero.h>
991
+ #include <ATen/ops/nonzero_numpy.h>
992
+ #include <ATen/ops/nonzero_static.h>
993
+ #include <ATen/ops/norm.h>
994
+ #include <ATen/ops/norm_except_dim.h>
995
+ #include <ATen/ops/normal.h>
996
+ #include <ATen/ops/not_equal.h>
997
+ #include <ATen/ops/nuclear_norm.h>
998
+ #include <ATen/ops/numpy_T.h>
999
+ #include <ATen/ops/one_hot.h>
1000
+ #include <ATen/ops/ones.h>
1001
+ #include <ATen/ops/ones_like.h>
1002
+ #include <ATen/ops/or.h>
1003
+ #include <ATen/ops/orgqr.h>
1004
+ #include <ATen/ops/ormqr.h>
1005
+ #include <ATen/ops/outer.h>
1006
+ #include <ATen/ops/output_nr.h>
1007
+ #include <ATen/ops/pad.h>
1008
+ #include <ATen/ops/pad_sequence.h>
1009
+ #include <ATen/ops/pairwise_distance.h>
1010
+ #include <ATen/ops/pdist.h>
1011
+ #include <ATen/ops/permute.h>
1012
+ #include <ATen/ops/permute_copy.h>
1013
+ #include <ATen/ops/pin_memory.h>
1014
+ #include <ATen/ops/pinverse.h>
1015
+ #include <ATen/ops/pixel_shuffle.h>
1016
+ #include <ATen/ops/pixel_unshuffle.h>
1017
+ #include <ATen/ops/poisson.h>
1018
+ #include <ATen/ops/poisson_nll_loss.h>
1019
+ #include <ATen/ops/polar.h>
1020
+ #include <ATen/ops/polygamma.h>
1021
+ #include <ATen/ops/positive.h>
1022
+ #include <ATen/ops/pow.h>
1023
+ #include <ATen/ops/prelu.h>
1024
+ #include <ATen/ops/prod.h>
1025
+ #include <ATen/ops/promote_types.h>
1026
+ #include <ATen/ops/put.h>
1027
+ #include <ATen/ops/q_per_channel_axis.h>
1028
+ #include <ATen/ops/q_per_channel_scales.h>
1029
+ #include <ATen/ops/q_per_channel_zero_points.h>
1030
+ #include <ATen/ops/q_scale.h>
1031
+ #include <ATen/ops/q_zero_point.h>
1032
+ #include <ATen/ops/qr.h>
1033
+ #include <ATen/ops/qscheme.h>
1034
+ #include <ATen/ops/quantile.h>
1035
+ #include <ATen/ops/quantize_per_channel.h>
1036
+ #include <ATen/ops/quantize_per_tensor.h>
1037
+ #include <ATen/ops/quantize_per_tensor_dynamic.h>
1038
+ #include <ATen/ops/quantized_batch_norm.h>
1039
+ #include <ATen/ops/quantized_gru_cell.h>
1040
+ #include <ATen/ops/quantized_lstm_cell.h>
1041
+ #include <ATen/ops/quantized_max_pool1d.h>
1042
+ #include <ATen/ops/quantized_max_pool2d.h>
1043
+ #include <ATen/ops/quantized_max_pool3d.h>
1044
+ #include <ATen/ops/quantized_rnn_relu_cell.h>
1045
+ #include <ATen/ops/quantized_rnn_tanh_cell.h>
1046
+ #include <ATen/ops/rad2deg.h>
1047
+ #include <ATen/ops/rand.h>
1048
+ #include <ATen/ops/rand_like.h>
1049
+ #include <ATen/ops/randint.h>
1050
+ #include <ATen/ops/randint_like.h>
1051
+ #include <ATen/ops/randn.h>
1052
+ #include <ATen/ops/randn_like.h>
1053
+ #include <ATen/ops/random.h>
1054
+ #include <ATen/ops/randperm.h>
1055
+ #include <ATen/ops/range.h>
1056
+ #include <ATen/ops/ravel.h>
1057
+ #include <ATen/ops/real.h>
1058
+ #include <ATen/ops/reciprocal.h>
1059
+ #include <ATen/ops/record_stream.h>
1060
+ #include <ATen/ops/refine_names.h>
1061
+ #include <ATen/ops/reflection_pad1d.h>
1062
+ #include <ATen/ops/reflection_pad1d_backward.h>
1063
+ #include <ATen/ops/reflection_pad2d.h>
1064
+ #include <ATen/ops/reflection_pad2d_backward.h>
1065
+ #include <ATen/ops/reflection_pad3d.h>
1066
+ #include <ATen/ops/reflection_pad3d_backward.h>
1067
+ #include <ATen/ops/relu.h>
1068
+ #include <ATen/ops/relu6.h>
1069
+ #include <ATen/ops/remainder.h>
1070
+ #include <ATen/ops/rename.h>
1071
+ #include <ATen/ops/renorm.h>
1072
+ #include <ATen/ops/repeat.h>
1073
+ #include <ATen/ops/repeat_interleave.h>
1074
+ #include <ATen/ops/replication_pad1d.h>
1075
+ #include <ATen/ops/replication_pad1d_backward.h>
1076
+ #include <ATen/ops/replication_pad2d.h>
1077
+ #include <ATen/ops/replication_pad2d_backward.h>
1078
+ #include <ATen/ops/replication_pad3d.h>
1079
+ #include <ATen/ops/replication_pad3d_backward.h>
1080
+ #include <ATen/ops/requires_grad.h>
1081
+ #include <ATen/ops/reshape.h>
1082
+ #include <ATen/ops/reshape_as.h>
1083
+ #include <ATen/ops/resize.h>
1084
+ #include <ATen/ops/resize_as.h>
1085
+ #include <ATen/ops/resize_as_sparse.h>
1086
+ #include <ATen/ops/resolve_conj.h>
1087
+ #include <ATen/ops/resolve_neg.h>
1088
+ #include <ATen/ops/result_type.h>
1089
+ #include <ATen/ops/retain_grad.h>
1090
+ #include <ATen/ops/retains_grad.h>
1091
+ #include <ATen/ops/rnn_relu.h>
1092
+ #include <ATen/ops/rnn_relu_cell.h>
1093
+ #include <ATen/ops/rnn_tanh.h>
1094
+ #include <ATen/ops/rnn_tanh_cell.h>
1095
+ #include <ATen/ops/roll.h>
1096
+ #include <ATen/ops/rot90.h>
1097
+ #include <ATen/ops/round.h>
1098
+ #include <ATen/ops/row_indices.h>
1099
+ #include <ATen/ops/row_indices_copy.h>
1100
+ #include <ATen/ops/row_stack.h>
1101
+ #include <ATen/ops/rrelu.h>
1102
+ #include <ATen/ops/rrelu_with_noise.h>
1103
+ #include <ATen/ops/rrelu_with_noise_backward.h>
1104
+ #include <ATen/ops/rshift.h>
1105
+ #include <ATen/ops/rsqrt.h>
1106
+ #include <ATen/ops/rsub.h>
1107
+ #include <ATen/ops/scalar_tensor.h>
1108
+ #include <ATen/ops/scaled_dot_product_attention.h>
1109
+ #include <ATen/ops/scatter.h>
1110
+ #include <ATen/ops/scatter_add.h>
1111
+ #include <ATen/ops/scatter_reduce.h>
1112
+ #include <ATen/ops/searchsorted.h>
1113
+ #include <ATen/ops/segment_reduce.h>
1114
+ #include <ATen/ops/select.h>
1115
+ #include <ATen/ops/select_backward.h>
1116
+ #include <ATen/ops/select_copy.h>
1117
+ #include <ATen/ops/select_scatter.h>
1118
+ #include <ATen/ops/selu.h>
1119
+ #include <ATen/ops/set.h>
1120
+ #include <ATen/ops/set_data.h>
1121
+ #include <ATen/ops/sgn.h>
1122
+ #include <ATen/ops/sigmoid.h>
1123
+ #include <ATen/ops/sigmoid_backward.h>
1124
+ #include <ATen/ops/sign.h>
1125
+ #include <ATen/ops/signbit.h>
1126
+ #include <ATen/ops/silu.h>
1127
+ #include <ATen/ops/silu_backward.h>
1128
+ #include <ATen/ops/sin.h>
1129
+ #include <ATen/ops/sinc.h>
1130
+ #include <ATen/ops/sinh.h>
1131
+ #include <ATen/ops/size.h>
1132
+ #include <ATen/ops/slice.h>
1133
+ #include <ATen/ops/slice_backward.h>
1134
+ #include <ATen/ops/slice_copy.h>
1135
+ #include <ATen/ops/slice_scatter.h>
1136
+ #include <ATen/ops/slogdet.h>
1137
+ #include <ATen/ops/slow_conv3d.h>
1138
+ #include <ATen/ops/slow_conv3d_forward.h>
1139
+ #include <ATen/ops/slow_conv_dilated2d.h>
1140
+ #include <ATen/ops/slow_conv_dilated3d.h>
1141
+ #include <ATen/ops/slow_conv_transpose2d.h>
1142
+ #include <ATen/ops/slow_conv_transpose3d.h>
1143
+ #include <ATen/ops/smm.h>
1144
+ #include <ATen/ops/smooth_l1_loss.h>
1145
+ #include <ATen/ops/smooth_l1_loss_backward.h>
1146
+ #include <ATen/ops/soft_margin_loss.h>
1147
+ #include <ATen/ops/soft_margin_loss_backward.h>
1148
+ #include <ATen/ops/softmax.h>
1149
+ #include <ATen/ops/softplus.h>
1150
+ #include <ATen/ops/softplus_backward.h>
1151
+ #include <ATen/ops/softshrink.h>
1152
+ #include <ATen/ops/softshrink_backward.h>
1153
+ #include <ATen/ops/sort.h>
1154
+ #include <ATen/ops/sparse_bsc_tensor.h>
1155
+ #include <ATen/ops/sparse_bsr_tensor.h>
1156
+ #include <ATen/ops/sparse_compressed_tensor.h>
1157
+ #include <ATen/ops/sparse_coo_tensor.h>
1158
+ #include <ATen/ops/sparse_csc_tensor.h>
1159
+ #include <ATen/ops/sparse_csr_tensor.h>
1160
+ #include <ATen/ops/sparse_dim.h>
1161
+ #include <ATen/ops/sparse_mask.h>
1162
+ #include <ATen/ops/sparse_resize.h>
1163
+ #include <ATen/ops/sparse_resize_and_clear.h>
1164
+ #include <ATen/ops/sparse_sampled_addmm.h>
1165
+ #include <ATen/ops/special_airy_ai.h>
1166
+ #include <ATen/ops/special_bessel_j0.h>
1167
+ #include <ATen/ops/special_bessel_j1.h>
1168
+ #include <ATen/ops/special_bessel_y0.h>
1169
+ #include <ATen/ops/special_bessel_y1.h>
1170
+ #include <ATen/ops/special_chebyshev_polynomial_t.h>
1171
+ #include <ATen/ops/special_chebyshev_polynomial_u.h>
1172
+ #include <ATen/ops/special_chebyshev_polynomial_v.h>
1173
+ #include <ATen/ops/special_chebyshev_polynomial_w.h>
1174
+ #include <ATen/ops/special_digamma.h>
1175
+ #include <ATen/ops/special_entr.h>
1176
+ #include <ATen/ops/special_erf.h>
1177
+ #include <ATen/ops/special_erfc.h>
1178
+ #include <ATen/ops/special_erfcx.h>
1179
+ #include <ATen/ops/special_erfinv.h>
1180
+ #include <ATen/ops/special_exp2.h>
1181
+ #include <ATen/ops/special_expit.h>
1182
+ #include <ATen/ops/special_expm1.h>
1183
+ #include <ATen/ops/special_gammainc.h>
1184
+ #include <ATen/ops/special_gammaincc.h>
1185
+ #include <ATen/ops/special_gammaln.h>
1186
+ #include <ATen/ops/special_hermite_polynomial_h.h>
1187
+ #include <ATen/ops/special_hermite_polynomial_he.h>
1188
+ #include <ATen/ops/special_i0.h>
1189
+ #include <ATen/ops/special_i0e.h>
1190
+ #include <ATen/ops/special_i1.h>
1191
+ #include <ATen/ops/special_i1e.h>
1192
+ #include <ATen/ops/special_laguerre_polynomial_l.h>
1193
+ #include <ATen/ops/special_legendre_polynomial_p.h>
1194
+ #include <ATen/ops/special_log1p.h>
1195
+ #include <ATen/ops/special_log_ndtr.h>
1196
+ #include <ATen/ops/special_log_softmax.h>
1197
+ #include <ATen/ops/special_logit.h>
1198
+ #include <ATen/ops/special_logsumexp.h>
1199
+ #include <ATen/ops/special_modified_bessel_i0.h>
1200
+ #include <ATen/ops/special_modified_bessel_i1.h>
1201
+ #include <ATen/ops/special_modified_bessel_k0.h>
1202
+ #include <ATen/ops/special_modified_bessel_k1.h>
1203
+ #include <ATen/ops/special_multigammaln.h>
1204
+ #include <ATen/ops/special_ndtr.h>
1205
+ #include <ATen/ops/special_ndtri.h>
1206
+ #include <ATen/ops/special_polygamma.h>
1207
+ #include <ATen/ops/special_psi.h>
1208
+ #include <ATen/ops/special_round.h>
1209
+ #include <ATen/ops/special_scaled_modified_bessel_k0.h>
1210
+ #include <ATen/ops/special_scaled_modified_bessel_k1.h>
1211
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_t.h>
1212
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_u.h>
1213
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_v.h>
1214
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_w.h>
1215
+ #include <ATen/ops/special_sinc.h>
1216
+ #include <ATen/ops/special_softmax.h>
1217
+ #include <ATen/ops/special_spherical_bessel_j0.h>
1218
+ #include <ATen/ops/special_xlog1py.h>
1219
+ #include <ATen/ops/special_xlogy.h>
1220
+ #include <ATen/ops/special_zeta.h>
1221
+ #include <ATen/ops/split.h>
1222
+ #include <ATen/ops/split_copy.h>
1223
+ #include <ATen/ops/split_with_sizes.h>
1224
+ #include <ATen/ops/split_with_sizes_copy.h>
1225
+ #include <ATen/ops/sqrt.h>
1226
+ #include <ATen/ops/square.h>
1227
+ #include <ATen/ops/squeeze.h>
1228
+ #include <ATen/ops/squeeze_copy.h>
1229
+ #include <ATen/ops/sspaddmm.h>
1230
+ #include <ATen/ops/stack.h>
1231
+ #include <ATen/ops/std.h>
1232
+ #include <ATen/ops/std_mean.h>
1233
+ #include <ATen/ops/stft.h>
1234
+ #include <ATen/ops/stride.h>
1235
+ #include <ATen/ops/sub.h>
1236
+ #include <ATen/ops/subtract.h>
1237
+ #include <ATen/ops/sum.h>
1238
+ #include <ATen/ops/sum_to_size.h>
1239
+ #include <ATen/ops/svd.h>
1240
+ #include <ATen/ops/swapaxes.h>
1241
+ #include <ATen/ops/swapdims.h>
1242
+ #include <ATen/ops/sym_constrain_range.h>
1243
+ #include <ATen/ops/sym_constrain_range_for_size.h>
1244
+ #include <ATen/ops/sym_numel.h>
1245
+ #include <ATen/ops/sym_size.h>
1246
+ #include <ATen/ops/sym_storage_offset.h>
1247
+ #include <ATen/ops/sym_stride.h>
1248
+ #include <ATen/ops/t.h>
1249
+ #include <ATen/ops/t_copy.h>
1250
+ #include <ATen/ops/take.h>
1251
+ #include <ATen/ops/take_along_dim.h>
1252
+ #include <ATen/ops/tan.h>
1253
+ #include <ATen/ops/tanh.h>
1254
+ #include <ATen/ops/tanh_backward.h>
1255
+ #include <ATen/ops/tensor_split.h>
1256
+ #include <ATen/ops/tensordot.h>
1257
+ #include <ATen/ops/thnn_conv2d.h>
1258
+ #include <ATen/ops/threshold.h>
1259
+ #include <ATen/ops/threshold_backward.h>
1260
+ #include <ATen/ops/tile.h>
1261
+ #include <ATen/ops/to.h>
1262
+ #include <ATen/ops/to_dense.h>
1263
+ #include <ATen/ops/to_dense_backward.h>
1264
+ #include <ATen/ops/to_mkldnn.h>
1265
+ #include <ATen/ops/to_mkldnn_backward.h>
1266
+ #include <ATen/ops/to_padded_tensor.h>
1267
+ #include <ATen/ops/to_sparse.h>
1268
+ #include <ATen/ops/to_sparse_bsc.h>
1269
+ #include <ATen/ops/to_sparse_bsr.h>
1270
+ #include <ATen/ops/to_sparse_csc.h>
1271
+ #include <ATen/ops/to_sparse_csr.h>
1272
+ #include <ATen/ops/topk.h>
1273
+ #include <ATen/ops/trace.h>
1274
+ #include <ATen/ops/trace_backward.h>
1275
+ #include <ATen/ops/transpose.h>
1276
+ #include <ATen/ops/transpose_copy.h>
1277
+ #include <ATen/ops/trapezoid.h>
1278
+ #include <ATen/ops/trapz.h>
1279
+ #include <ATen/ops/triangular_solve.h>
1280
+ #include <ATen/ops/tril.h>
1281
+ #include <ATen/ops/tril_indices.h>
1282
+ #include <ATen/ops/triplet_margin_loss.h>
1283
+ #include <ATen/ops/triu.h>
1284
+ #include <ATen/ops/triu_indices.h>
1285
+ #include <ATen/ops/true_divide.h>
1286
+ #include <ATen/ops/trunc.h>
1287
+ #include <ATen/ops/type_as.h>
1288
+ #include <ATen/ops/unbind.h>
1289
+ #include <ATen/ops/unbind_copy.h>
1290
+ #include <ATen/ops/unflatten.h>
1291
+ #include <ATen/ops/unflatten_dense_tensors.h>
1292
+ #include <ATen/ops/unfold.h>
1293
+ #include <ATen/ops/unfold_backward.h>
1294
+ #include <ATen/ops/unfold_copy.h>
1295
+ #include <ATen/ops/uniform.h>
1296
+ #include <ATen/ops/unique_consecutive.h>
1297
+ #include <ATen/ops/unique_dim.h>
1298
+ #include <ATen/ops/unique_dim_consecutive.h>
1299
+ #include <ATen/ops/unsafe_chunk.h>
1300
+ #include <ATen/ops/unsafe_split.h>
1301
+ #include <ATen/ops/unsafe_split_with_sizes.h>
1302
+ #include <ATen/ops/unsqueeze.h>
1303
+ #include <ATen/ops/unsqueeze_copy.h>
1304
+ #include <ATen/ops/upsample_bicubic2d.h>
1305
+ #include <ATen/ops/upsample_bicubic2d_backward.h>
1306
+ #include <ATen/ops/upsample_bilinear2d.h>
1307
+ #include <ATen/ops/upsample_bilinear2d_backward.h>
1308
+ #include <ATen/ops/upsample_linear1d.h>
1309
+ #include <ATen/ops/upsample_linear1d_backward.h>
1310
+ #include <ATen/ops/upsample_nearest1d.h>
1311
+ #include <ATen/ops/upsample_nearest1d_backward.h>
1312
+ #include <ATen/ops/upsample_nearest2d.h>
1313
+ #include <ATen/ops/upsample_nearest2d_backward.h>
1314
+ #include <ATen/ops/upsample_nearest3d.h>
1315
+ #include <ATen/ops/upsample_nearest3d_backward.h>
1316
+ #include <ATen/ops/upsample_trilinear3d.h>
1317
+ #include <ATen/ops/upsample_trilinear3d_backward.h>
1318
+ #include <ATen/ops/value_selecting_reduction_backward.h>
1319
+ #include <ATen/ops/values.h>
1320
+ #include <ATen/ops/values_copy.h>
1321
+ #include <ATen/ops/vander.h>
1322
+ #include <ATen/ops/var.h>
1323
+ #include <ATen/ops/var_mean.h>
1324
+ #include <ATen/ops/vdot.h>
1325
+ #include <ATen/ops/view.h>
1326
+ #include <ATen/ops/view_as.h>
1327
+ #include <ATen/ops/view_as_complex.h>
1328
+ #include <ATen/ops/view_as_complex_copy.h>
1329
+ #include <ATen/ops/view_as_real.h>
1330
+ #include <ATen/ops/view_as_real_copy.h>
1331
+ #include <ATen/ops/view_copy.h>
1332
+ #include <ATen/ops/vsplit.h>
1333
+ #include <ATen/ops/vstack.h>
1334
+ #include <ATen/ops/where.h>
1335
+ #include <ATen/ops/xlogy.h>
1336
+ #include <ATen/ops/xor.h>
1337
+ #include <ATen/ops/zero.h>
1338
+ #include <ATen/ops/zeros.h>
1339
+ #include <ATen/ops/zeros_like.h>
1340
+
1341
+ namespace at {
1342
+
1343
+
1344
+
1345
+ // Special C++ only overloads for std()-like functions (See gh-40287)
1346
+ // These are needed because int -> bool conversion takes precedence over int -> IntArrayRef
1347
+ // So, for example std(0) would select the std(unbiased=False) overload
1348
+ TORCH_API inline Tensor var(const Tensor& self, int dim) {
1349
+ return at::var(self, IntArrayRef{dim});
1350
+ }
1351
+ TORCH_API inline std::tuple<Tensor, Tensor> var_mean(const Tensor& self, int dim) {
1352
+ return at::var_mean(self, IntArrayRef{dim});
1353
+ }
1354
+ TORCH_API inline Tensor std(const Tensor& self, int dim) {
1355
+ return at::std(self, IntArrayRef{dim});
1356
+ }
1357
+ TORCH_API inline std::tuple<Tensor, Tensor> std_mean(const Tensor& self, int dim) {
1358
+ return at::std_mean(self, IntArrayRef{dim});
1359
+ }
1360
+
1361
+ inline int64_t numel(const Tensor& tensor) {
1362
+ return tensor.numel();
1363
+ }
1364
+
1365
+ inline int64_t size(const Tensor& tensor, int64_t dim) {
1366
+ return tensor.size(dim);
1367
+ }
1368
+
1369
+ inline int64_t stride(const Tensor& tensor, int64_t dim) {
1370
+ return tensor.stride(dim);
1371
+ }
1372
+
1373
+ inline bool is_complex(const Tensor& tensor) {
1374
+ return tensor.is_complex();
1375
+ }
1376
+
1377
+ inline bool is_floating_point(const Tensor& tensor) {
1378
+ return tensor.is_floating_point();
1379
+ }
1380
+
1381
+ inline bool is_signed(const Tensor& tensor) {
1382
+ return tensor.is_signed();
1383
+ }
1384
+
1385
+ inline bool is_inference(const Tensor& tensor) {
1386
+ return tensor.is_inference();
1387
+ }
1388
+
1389
+ inline bool _is_zerotensor(const Tensor& tensor) {
1390
+ return tensor._is_zerotensor();
1391
+ }
1392
+
1393
+ inline bool is_conj(const Tensor& tensor) {
1394
+ return tensor.is_conj();
1395
+ }
1396
+
1397
+ inline Tensor conj(const Tensor& tensor) {
1398
+ return tensor.conj();
1399
+ }
1400
+
1401
+ inline bool is_neg(const Tensor& tensor) {
1402
+ return tensor.is_neg();
1403
+ }
1404
+
1405
+ }
videollama2/lib/python3.10/site-packages/torch/include/ATen/InferSize.h ADDED
@@ -0,0 +1,87 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/DimVector.h>
4
+ #include <c10/core/ScalarType.h>
5
+ #include <c10/core/SymIntArrayRef.h>
6
+ #include <c10/util/DimVector.h>
7
+ #include <c10/util/Optional.h>
8
+ #include <sstream>
9
+ #include <vector>
10
+
11
+ namespace at {
12
+
13
+ // Infers the size of a dim with size -1, if it exists. Also checks that new
14
+ // shape is compatible with the number of elements.
15
+ //
16
+ // templated to handle std::vector<int64_t> and DimVector use cases, see
17
+ // below
18
+ //
19
+ template <typename InputArrayRef, typename NumelType, typename ResultVec>
20
+ inline void infer_size_impl(
21
+ InputArrayRef shape,
22
+ NumelType numel,
23
+ ResultVec& res) {
24
+ NumelType newsize = 1;
25
+ // N.B. this is an index, not a sym dim!
26
+ auto infer_dim = c10::optional<int64_t>();
27
+ for (int64_t dim = 0, ndim = shape.size(); dim != ndim; dim++) {
28
+ if (shape[dim] == -1) {
29
+ if (infer_dim) {
30
+ throw std::runtime_error("only one dimension can be inferred");
31
+ }
32
+ infer_dim = dim;
33
+ } else if (shape[dim] >= 0) {
34
+ newsize *= shape[dim];
35
+ } else {
36
+ AT_ERROR("invalid shape dimension ", shape[dim]);
37
+ }
38
+ }
39
+
40
+ if (numel == newsize || (infer_dim && newsize > 0 && numel % newsize == 0)) {
41
+ if (infer_dim) {
42
+ // We have a degree of freedom here to select the dimension size; follow
43
+ // NumPy semantics and just bail. However, a nice error message is needed
44
+ // because users often use `view` as a way to flatten & unflatten
45
+ // dimensions and will otherwise be confused why
46
+ // empty_tensor.view( 0, 0)
47
+ // works yet
48
+ // empty_tensor.view(-1, 0)
49
+ // doesn't.
50
+ TORCH_CHECK(
51
+ newsize != 0,
52
+ "cannot reshape tensor of 0 elements into shape ",
53
+ shape,
54
+ " because the unspecified dimension size -1 can be any "
55
+ "value and is ambiguous");
56
+ res[*infer_dim] = numel / newsize;
57
+ }
58
+ return;
59
+ }
60
+
61
+ std::ostringstream ss;
62
+ ss << "shape '" << shape << "' is invalid for input of size " << numel;
63
+ throw std::runtime_error(ss.str());
64
+ }
65
+
66
+ inline std::vector<int64_t> infer_size(IntArrayRef shape, int64_t numel) {
67
+ auto res = shape.vec();
68
+ infer_size_impl(shape, numel, res);
69
+ return res;
70
+ }
71
+
72
+ inline at::DimVector infer_size_dv(IntArrayRef shape, int64_t numel) {
73
+ auto res = at::DimVector(shape);
74
+ infer_size_impl(shape, numel, res);
75
+ return res;
76
+ }
77
+
78
+ inline at::SymDimVector infer_size_dv(
79
+ c10::SymIntArrayRef shape,
80
+ c10::SymInt numel) {
81
+ auto res = at::SymDimVector(shape);
82
+ infer_size_impl<c10::SymIntArrayRef, c10::SymInt, at::SymDimVector>(
83
+ shape, std::move(numel), res);
84
+ return res;
85
+ }
86
+
87
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/InitialTensorOptions.h ADDED
@@ -0,0 +1,15 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/core/TensorOptions.h>
4
+
5
+ namespace at {
6
+
7
+ // Represents the initial TensorOptions, before the "defaults" are ever changed.
8
+ // This is designed to be used in library code, where the explicit devices,
9
+ // dtypes, etc. are known. NOTE: this is not a stable API.
10
+ inline TensorOptions initialTensorOptions() {
11
+ return TensorOptions(kCPU).dtype(kFloat).layout(kStrided).requires_grad(
12
+ false);
13
+ }
14
+
15
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/LegacyVmapMode.h ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/core/impl/LocalDispatchKeySet.h>
4
+
5
+ namespace at::impl {
6
+
7
+ // VmapMode contains a thread local count of how many nested vmaps
8
+ // we are currently inside. That number is known as the `vmap level`.
9
+ // VmapMode is used in the implementation of the Python `torch.vmap` API.
10
+ //
11
+ // NOTE: this is NOT the c++ api for torch.vmap. That doesn't exist yet.
12
+
13
+ struct TORCH_API VmapMode {
14
+ // Returns the vmap level, aka the count of how many nested vmaps we're in.
15
+ static int64_t current_vmap_level();
16
+
17
+ // Increment the count of nested vmaps. If this causes the vmap level to be
18
+ // greater than 0, then it enables DispatchKey::VmapMode on all tensors.
19
+ static int64_t increment_nesting();
20
+
21
+ // Decrements the count of nested vmaps. If this causes the vmap level to be
22
+ // equal to 0, then it disables DispatchKey::VmapMode on all tensors.
23
+ static int64_t decrement_nesting();
24
+ };
25
+
26
+ } // namespace at::impl
videollama2/lib/python3.10/site-packages/torch/include/ATen/LinalgBackend.h ADDED
@@ -0,0 +1,31 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/util/Exception.h>
4
+
5
+ #include <ostream>
6
+ #include <string>
7
+
8
+ namespace at {
9
+
10
+ enum class LinalgBackend : int8_t { Default, Cusolver, Magma };
11
+
12
+ inline std::string LinalgBackendToString(at::LinalgBackend backend) {
13
+ switch (backend) {
14
+ case LinalgBackend::Default:
15
+ return "at::LinalgBackend::Default";
16
+ case LinalgBackend::Cusolver:
17
+ return "at::LinalgBackend::Cusolver";
18
+ case LinalgBackend::Magma:
19
+ return "at::LinalgBackend::Magma";
20
+ default:
21
+ TORCH_CHECK(false, "Unknown linalg backend");
22
+ }
23
+ }
24
+
25
+ inline std::ostream& operator<<(
26
+ std::ostream& stream,
27
+ at::LinalgBackend backend) {
28
+ return stream << LinalgBackendToString(backend);
29
+ }
30
+
31
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/MapAllocator.h ADDED
@@ -0,0 +1,139 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/core/Allocator.h>
4
+ #include <c10/util/string_view.h>
5
+
6
+ namespace at {
7
+
8
+ enum MappedAllocatorModes {
9
+ ALLOCATOR_MAPPED_SHARED = 1,
10
+ ALLOCATOR_MAPPED_SHAREDMEM = 2,
11
+ ALLOCATOR_MAPPED_EXCLUSIVE = 4,
12
+ ALLOCATOR_MAPPED_NOCREATE = 8,
13
+ ALLOCATOR_MAPPED_KEEPFD = 16,
14
+ ALLOCATOR_MAPPED_FROMFD = 32,
15
+ ALLOCATOR_MAPPED_UNLINK = 64
16
+ };
17
+
18
+ // Sentinel value/type to help distinguish the file descriptor constructor from
19
+ // the non-file descriptor constructor
20
+ enum WithFd { WITH_FD };
21
+
22
+ TORCH_API std::string NewProcessWideShmHandle();
23
+
24
+ class TORCH_API MapAllocator {
25
+ public:
26
+ MapAllocator(c10::string_view filename, int flags, size_t size);
27
+ MapAllocator(
28
+ WithFd,
29
+ c10::string_view filename,
30
+ int fd,
31
+ int flags,
32
+ size_t size);
33
+ MapAllocator(const MapAllocator&) = delete;
34
+ MapAllocator& operator=(const MapAllocator&) = delete;
35
+ MapAllocator(MapAllocator&&) = delete;
36
+ MapAllocator& operator=(MapAllocator&&) = delete;
37
+
38
+ const char* filename() const {
39
+ return filename_.c_str();
40
+ }
41
+ int fd() const {
42
+ #ifdef _WIN32
43
+ TORCH_CHECK(false, "MapAllocator::fd() is unsupported on Windows");
44
+ #else
45
+ return fd_;
46
+ #endif
47
+ }
48
+ ptrdiff_t size() const {
49
+ return size_;
50
+ }
51
+ // Return a pointer to the actual data for this allocator
52
+ // (in the case of the refcounted allocator, this is offset
53
+ // from the base pointer.)
54
+ virtual void* data() const {
55
+ return base_ptr_;
56
+ }
57
+
58
+ static MapAllocator* fromDataPtr(const at::DataPtr&);
59
+ static at::DataPtr makeDataPtr(
60
+ c10::string_view filename,
61
+ int flags,
62
+ size_t size,
63
+ size_t* actual_size_out);
64
+ static at::DataPtr makeDataPtr(
65
+ WithFd,
66
+ const char* filename,
67
+ int fd,
68
+ int flags,
69
+ size_t size,
70
+ size_t* actual_size_out);
71
+
72
+ // Closes the data. Helps us avoid destructor shenanigans
73
+ virtual void close();
74
+
75
+ // This is very dangerous. You have to redefine this destructor for each
76
+ // subclass
77
+ virtual ~MapAllocator();
78
+
79
+ protected:
80
+ bool closed_ = false;
81
+ std::string filename_;
82
+ int flags_ = 0;
83
+ ptrdiff_t size_; /* mapped size */
84
+ #ifdef _WIN32
85
+ void* handle_;
86
+ void* event_;
87
+ std::string eventname_;
88
+ #else
89
+ int fd_ = -1;
90
+ #endif
91
+ void* base_ptr_ = nullptr;
92
+ };
93
+
94
+ // Base-from-member idiom
95
+ struct TORCH_API RefcountedMapAllocatorArgCheck {
96
+ RefcountedMapAllocatorArgCheck(int flags);
97
+ };
98
+
99
+ class TORCH_API RefcountedMapAllocator : private RefcountedMapAllocatorArgCheck,
100
+ public MapAllocator {
101
+ public:
102
+ RefcountedMapAllocator(const char* filename, int flags, size_t size);
103
+ RefcountedMapAllocator(
104
+ WithFd,
105
+ const char* filename,
106
+ int fd,
107
+ int flags,
108
+ size_t size);
109
+
110
+ static RefcountedMapAllocator* fromDataPtr(const at::DataPtr&);
111
+ static at::DataPtr makeDataPtr(
112
+ const char* filename,
113
+ int flags,
114
+ size_t size,
115
+ size_t* actual_size_out);
116
+ static at::DataPtr makeDataPtr(
117
+ WithFd,
118
+ const char* filename,
119
+ int fd,
120
+ int flags,
121
+ size_t size,
122
+ size_t* actual_size_out);
123
+
124
+ void* data() const override;
125
+
126
+ void incref();
127
+ int decref();
128
+ void close() override;
129
+
130
+ ~RefcountedMapAllocator() override {
131
+ close();
132
+ }
133
+
134
+ protected:
135
+ void checkFlags();
136
+ void initializeAlloc();
137
+ };
138
+
139
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/MatrixRef.h ADDED
@@ -0,0 +1,109 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ #include <ATen/Utils.h>
3
+ #include <c10/util/ArrayRef.h>
4
+
5
+ #include <vector>
6
+
7
+ namespace at {
8
+ /// MatrixRef - Like an ArrayRef, but with an extra recorded strides so that
9
+ /// we can easily view it as a multidimensional array.
10
+ ///
11
+ /// Like ArrayRef, this class does not own the underlying data, it is expected
12
+ /// to be used in situations where the data resides in some other buffer.
13
+ ///
14
+ /// This is intended to be trivially copyable, so it should be passed by
15
+ /// value.
16
+ ///
17
+ /// For now, 2D only (so the copies are actually cheap, without having
18
+ /// to write a SmallVector class) and contiguous only (so we can
19
+ /// return non-strided ArrayRef on index).
20
+ ///
21
+ /// P.S. dimension 0 indexes rows, dimension 1 indexes columns
22
+ template <typename T>
23
+ class MatrixRef {
24
+ public:
25
+ typedef size_t size_type;
26
+
27
+ private:
28
+ /// Underlying ArrayRef
29
+ ArrayRef<T> arr;
30
+
31
+ /// Stride of dim 0 (outer dimension)
32
+ size_type stride0;
33
+
34
+ // Stride of dim 1 is assumed to be 1
35
+
36
+ public:
37
+ /// Construct an empty Matrixref.
38
+ /*implicit*/ MatrixRef() : arr(nullptr), stride0(0) {}
39
+
40
+ /// Construct an MatrixRef from an ArrayRef and outer stride.
41
+ /*implicit*/ MatrixRef(ArrayRef<T> arr, size_type stride0)
42
+ : arr(arr), stride0(stride0) {
43
+ TORCH_CHECK(
44
+ arr.size() % stride0 == 0,
45
+ "MatrixRef: ArrayRef size ",
46
+ arr.size(),
47
+ " not divisible by stride ",
48
+ stride0)
49
+ }
50
+
51
+ /// @}
52
+ /// @name Simple Operations
53
+ /// @{
54
+
55
+ /// empty - Check if the matrix is empty.
56
+ bool empty() const {
57
+ return arr.empty();
58
+ }
59
+
60
+ const T* data() const {
61
+ return arr.data();
62
+ }
63
+
64
+ /// size - Get size a dimension
65
+ size_t size(size_t dim) const {
66
+ if (dim == 0) {
67
+ return arr.size() / stride0;
68
+ } else if (dim == 1) {
69
+ return stride0;
70
+ } else {
71
+ TORCH_CHECK(
72
+ 0, "MatrixRef: out of bounds dimension ", dim, "; expected 0 or 1");
73
+ }
74
+ }
75
+
76
+ size_t numel() const {
77
+ return arr.size();
78
+ }
79
+
80
+ /// equals - Check for element-wise equality.
81
+ bool equals(MatrixRef RHS) const {
82
+ return stride0 == RHS.stride0 && arr.equals(RHS.arr);
83
+ }
84
+
85
+ /// @}
86
+ /// @name Operator Overloads
87
+ /// @{
88
+ ArrayRef<T> operator[](size_t Index) const {
89
+ return arr.slice(Index * stride0, stride0);
90
+ }
91
+
92
+ /// Disallow accidental assignment from a temporary.
93
+ ///
94
+ /// The declaration here is extra complicated so that "arrayRef = {}"
95
+ /// continues to select the move assignment operator.
96
+ template <typename U>
97
+ typename std::enable_if<std::is_same<U, T>::value, MatrixRef<T>>::type&
98
+ operator=(U&& Temporary) = delete;
99
+
100
+ /// Disallow accidental assignment from a temporary.
101
+ ///
102
+ /// The declaration here is extra complicated so that "arrayRef = {}"
103
+ /// continues to select the move assignment operator.
104
+ template <typename U>
105
+ typename std::enable_if<std::is_same<U, T>::value, MatrixRef<T>>::type&
106
+ operator=(std::initializer_list<U>) = delete;
107
+ };
108
+
109
+ } // end namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/MetaFunctions.h ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #include <ATen/core/TensorBody.h>
2
+
3
+ // TODO Undo all logic introduced for Note [Avoiding Include Cycles In Static Dispatch]
4
+ // Code introduced to avoid cyclic dependency in static dispatch is no longer
5
+ // needed as static dispatch logic is moved from TensorBody.h, which caused cycles in the first place,
6
+ // to Operators.cpp for supporting multiple backends with multiple kernels.
7
+ //
8
+ // Note [Avoiding Include Cycles In Static Dispatch]
9
+ // In order to avoid #include cycles in the static dispatch build, we've carefully split out
10
+ // the static function definition files into {DispatchKey}Functions.h and {DispatchKey}Functions_inl.h.
11
+ //
12
+ // Without this split, the include cycle looks like TensorBody.h -> CPUFunctions.h -> TensorBody.h.
13
+ // - TensorBody.h #includes CPUFunctions.h in the static dispatch build, because the tensor methods
14
+ // all need to call into the fastpath C++ API defined in CPUFunctions.h. The methods are also all
15
+ // directly inlined into TensorBody.h.
16
+ // - CPUFunctions.h #includes TensorBody.h because it contains function declarations for the entire C++ API,
17
+ // which include functions that have defaultable optional<Tensor> arguments.
18
+ // That requires knowing the full Tensor class definition.
19
+ //
20
+ // We break the cycle by doing the following:
21
+ // - Split out CPUFunction.h into two files: CPUFunctions.h and CPUFunctions_inl.h
22
+ // - CPUFunction.h is a dummy file that just includes the Tensor class and includes CPUFunctions_inl.,
23
+ // - CPUFunctions_inl.h includes everything else
24
+ // - (only in the static dispatch build) TensorBody.h makes sure to finish defining the Tensor class,
25
+ // and then it includes CPUFunctions_inl.h.
26
+ // - All other files that want the cpu fastpath functions can include CPUFunctions.h directly.
27
+ // - This also means that static dispatch build, CPUFunctions.h only needs to
28
+ // #include TensorBody.h, and it will automatically bring in CPUFunctions_inl.h.
29
+ #include <ATen/MetaFunctions_inl.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/MethodOperators.h ADDED
@@ -0,0 +1,441 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from MethodOperators.h
4
+
5
+ #ifdef TORCH_ASSERT_NO_OPERATORS
6
+ #error This change adds a dependency on native_functions.yaml, \
7
+ meaning the file will need to be re-compiled every time an operator \
8
+ is changed or added. Consider if your change would be better placed in \
9
+ another file, or if a more specific header might achieve the same goal. \
10
+ See NOTE: [Tensor vs. TensorBase]
11
+ #endif
12
+
13
+ // Forward declarations of any types needed in the operator signatures.
14
+ // We can't directly include these classes because it will cause circular include dependencies.
15
+ // This file is included by TensorBody.h, which defines the Tensor class.
16
+ #include <ATen/core/ATen_fwd.h>
17
+
18
+ #include <ATen/ops/_addmm_activation_ops.h>
19
+ #include <ATen/ops/_autocast_to_full_precision_ops.h>
20
+ #include <ATen/ops/_autocast_to_reduced_precision_ops.h>
21
+ #include <ATen/ops/_backward_ops.h>
22
+ #include <ATen/ops/_coalesced_ops.h>
23
+ #include <ATen/ops/_conj_ops.h>
24
+ #include <ATen/ops/_conj_physical_ops.h>
25
+ #include <ATen/ops/_dimI_ops.h>
26
+ #include <ATen/ops/_dimV_ops.h>
27
+ #include <ATen/ops/_fw_primal_ops.h>
28
+ #include <ATen/ops/_indices_ops.h>
29
+ #include <ATen/ops/_is_all_true_ops.h>
30
+ #include <ATen/ops/_is_any_true_ops.h>
31
+ #include <ATen/ops/_is_zerotensor_ops.h>
32
+ #include <ATen/ops/_neg_view_ops.h>
33
+ #include <ATen/ops/_nested_tensor_size_ops.h>
34
+ #include <ATen/ops/_nested_tensor_storage_offsets_ops.h>
35
+ #include <ATen/ops/_nested_tensor_strides_ops.h>
36
+ #include <ATen/ops/_nnz_ops.h>
37
+ #include <ATen/ops/_reshape_alias_ops.h>
38
+ #include <ATen/ops/_sparse_mask_projection_ops.h>
39
+ #include <ATen/ops/_to_dense_ops.h>
40
+ #include <ATen/ops/_to_sparse_bsc_ops.h>
41
+ #include <ATen/ops/_to_sparse_bsr_ops.h>
42
+ #include <ATen/ops/_to_sparse_csc_ops.h>
43
+ #include <ATen/ops/_to_sparse_csr_ops.h>
44
+ #include <ATen/ops/_to_sparse_ops.h>
45
+ #include <ATen/ops/_values_ops.h>
46
+ #include <ATen/ops/_version_ops.h>
47
+ #include <ATen/ops/abs_ops.h>
48
+ #include <ATen/ops/absolute_ops.h>
49
+ #include <ATen/ops/acos_ops.h>
50
+ #include <ATen/ops/acosh_ops.h>
51
+ #include <ATen/ops/add_ops.h>
52
+ #include <ATen/ops/addbmm_ops.h>
53
+ #include <ATen/ops/addcdiv_ops.h>
54
+ #include <ATen/ops/addcmul_ops.h>
55
+ #include <ATen/ops/addmm_ops.h>
56
+ #include <ATen/ops/addmv_ops.h>
57
+ #include <ATen/ops/addr_ops.h>
58
+ #include <ATen/ops/adjoint_ops.h>
59
+ #include <ATen/ops/alias_ops.h>
60
+ #include <ATen/ops/align_as_ops.h>
61
+ #include <ATen/ops/align_to_ops.h>
62
+ #include <ATen/ops/all_ops.h>
63
+ #include <ATen/ops/allclose_ops.h>
64
+ #include <ATen/ops/amax_ops.h>
65
+ #include <ATen/ops/amin_ops.h>
66
+ #include <ATen/ops/aminmax_ops.h>
67
+ #include <ATen/ops/and_ops.h>
68
+ #include <ATen/ops/angle_ops.h>
69
+ #include <ATen/ops/any_ops.h>
70
+ #include <ATen/ops/arccos_ops.h>
71
+ #include <ATen/ops/arccosh_ops.h>
72
+ #include <ATen/ops/arcsin_ops.h>
73
+ #include <ATen/ops/arcsinh_ops.h>
74
+ #include <ATen/ops/arctan2_ops.h>
75
+ #include <ATen/ops/arctan_ops.h>
76
+ #include <ATen/ops/arctanh_ops.h>
77
+ #include <ATen/ops/argmax_ops.h>
78
+ #include <ATen/ops/argmin_ops.h>
79
+ #include <ATen/ops/argsort_ops.h>
80
+ #include <ATen/ops/argwhere_ops.h>
81
+ #include <ATen/ops/as_strided_ops.h>
82
+ #include <ATen/ops/as_strided_scatter_ops.h>
83
+ #include <ATen/ops/asin_ops.h>
84
+ #include <ATen/ops/asinh_ops.h>
85
+ #include <ATen/ops/atan2_ops.h>
86
+ #include <ATen/ops/atan_ops.h>
87
+ #include <ATen/ops/atanh_ops.h>
88
+ #include <ATen/ops/baddbmm_ops.h>
89
+ #include <ATen/ops/bernoulli_ops.h>
90
+ #include <ATen/ops/bincount_ops.h>
91
+ #include <ATen/ops/bitwise_and_ops.h>
92
+ #include <ATen/ops/bitwise_left_shift_ops.h>
93
+ #include <ATen/ops/bitwise_not_ops.h>
94
+ #include <ATen/ops/bitwise_or_ops.h>
95
+ #include <ATen/ops/bitwise_right_shift_ops.h>
96
+ #include <ATen/ops/bitwise_xor_ops.h>
97
+ #include <ATen/ops/bmm_ops.h>
98
+ #include <ATen/ops/broadcast_to_ops.h>
99
+ #include <ATen/ops/cauchy_ops.h>
100
+ #include <ATen/ops/ccol_indices_ops.h>
101
+ #include <ATen/ops/ceil_ops.h>
102
+ #include <ATen/ops/chalf_ops.h>
103
+ #include <ATen/ops/cholesky_inverse_ops.h>
104
+ #include <ATen/ops/cholesky_ops.h>
105
+ #include <ATen/ops/cholesky_solve_ops.h>
106
+ #include <ATen/ops/chunk_ops.h>
107
+ #include <ATen/ops/clamp_max_ops.h>
108
+ #include <ATen/ops/clamp_min_ops.h>
109
+ #include <ATen/ops/clamp_ops.h>
110
+ #include <ATen/ops/clip_ops.h>
111
+ #include <ATen/ops/clone_ops.h>
112
+ #include <ATen/ops/coalesce_ops.h>
113
+ #include <ATen/ops/col_indices_ops.h>
114
+ #include <ATen/ops/conj_ops.h>
115
+ #include <ATen/ops/conj_physical_ops.h>
116
+ #include <ATen/ops/contiguous_ops.h>
117
+ #include <ATen/ops/copy_ops.h>
118
+ #include <ATen/ops/copysign_ops.h>
119
+ #include <ATen/ops/corrcoef_ops.h>
120
+ #include <ATen/ops/cos_ops.h>
121
+ #include <ATen/ops/cosh_ops.h>
122
+ #include <ATen/ops/count_nonzero_ops.h>
123
+ #include <ATen/ops/cov_ops.h>
124
+ #include <ATen/ops/cross_ops.h>
125
+ #include <ATen/ops/crow_indices_ops.h>
126
+ #include <ATen/ops/cummax_ops.h>
127
+ #include <ATen/ops/cummin_ops.h>
128
+ #include <ATen/ops/cumprod_ops.h>
129
+ #include <ATen/ops/cumsum_ops.h>
130
+ #include <ATen/ops/data_ops.h>
131
+ #include <ATen/ops/deg2rad_ops.h>
132
+ #include <ATen/ops/dense_dim_ops.h>
133
+ #include <ATen/ops/dequantize_ops.h>
134
+ #include <ATen/ops/det_ops.h>
135
+ #include <ATen/ops/detach_ops.h>
136
+ #include <ATen/ops/diag_embed_ops.h>
137
+ #include <ATen/ops/diag_ops.h>
138
+ #include <ATen/ops/diagflat_ops.h>
139
+ #include <ATen/ops/diagonal_ops.h>
140
+ #include <ATen/ops/diagonal_scatter_ops.h>
141
+ #include <ATen/ops/diff_ops.h>
142
+ #include <ATen/ops/digamma_ops.h>
143
+ #include <ATen/ops/dist_ops.h>
144
+ #include <ATen/ops/div_ops.h>
145
+ #include <ATen/ops/divide_ops.h>
146
+ #include <ATen/ops/dot_ops.h>
147
+ #include <ATen/ops/dsplit_ops.h>
148
+ #include <ATen/ops/eq_ops.h>
149
+ #include <ATen/ops/equal_ops.h>
150
+ #include <ATen/ops/erf_ops.h>
151
+ #include <ATen/ops/erfc_ops.h>
152
+ #include <ATen/ops/erfinv_ops.h>
153
+ #include <ATen/ops/exp2_ops.h>
154
+ #include <ATen/ops/exp_ops.h>
155
+ #include <ATen/ops/expand_as_ops.h>
156
+ #include <ATen/ops/expand_ops.h>
157
+ #include <ATen/ops/expm1_ops.h>
158
+ #include <ATen/ops/exponential_ops.h>
159
+ #include <ATen/ops/fill_diagonal_ops.h>
160
+ #include <ATen/ops/fill_ops.h>
161
+ #include <ATen/ops/fix_ops.h>
162
+ #include <ATen/ops/flatten_ops.h>
163
+ #include <ATen/ops/flip_ops.h>
164
+ #include <ATen/ops/fliplr_ops.h>
165
+ #include <ATen/ops/flipud_ops.h>
166
+ #include <ATen/ops/float_power_ops.h>
167
+ #include <ATen/ops/floor_divide_ops.h>
168
+ #include <ATen/ops/floor_ops.h>
169
+ #include <ATen/ops/fmax_ops.h>
170
+ #include <ATen/ops/fmin_ops.h>
171
+ #include <ATen/ops/fmod_ops.h>
172
+ #include <ATen/ops/frac_ops.h>
173
+ #include <ATen/ops/frexp_ops.h>
174
+ #include <ATen/ops/gather_ops.h>
175
+ #include <ATen/ops/gcd_ops.h>
176
+ #include <ATen/ops/ge_ops.h>
177
+ #include <ATen/ops/geometric_ops.h>
178
+ #include <ATen/ops/geqrf_ops.h>
179
+ #include <ATen/ops/ger_ops.h>
180
+ #include <ATen/ops/greater_equal_ops.h>
181
+ #include <ATen/ops/greater_ops.h>
182
+ #include <ATen/ops/gt_ops.h>
183
+ #include <ATen/ops/hardshrink_backward_ops.h>
184
+ #include <ATen/ops/hardshrink_ops.h>
185
+ #include <ATen/ops/heaviside_ops.h>
186
+ #include <ATen/ops/histc_ops.h>
187
+ #include <ATen/ops/histogram_ops.h>
188
+ #include <ATen/ops/hsplit_ops.h>
189
+ #include <ATen/ops/hypot_ops.h>
190
+ #include <ATen/ops/i0_ops.h>
191
+ #include <ATen/ops/igamma_ops.h>
192
+ #include <ATen/ops/igammac_ops.h>
193
+ #include <ATen/ops/index_add_ops.h>
194
+ #include <ATen/ops/index_copy_ops.h>
195
+ #include <ATen/ops/index_fill_ops.h>
196
+ #include <ATen/ops/index_ops.h>
197
+ #include <ATen/ops/index_put_ops.h>
198
+ #include <ATen/ops/index_reduce_ops.h>
199
+ #include <ATen/ops/index_select_ops.h>
200
+ #include <ATen/ops/indices_ops.h>
201
+ #include <ATen/ops/inner_ops.h>
202
+ #include <ATen/ops/int_repr_ops.h>
203
+ #include <ATen/ops/inverse_ops.h>
204
+ #include <ATen/ops/is_coalesced_ops.h>
205
+ #include <ATen/ops/is_complex_ops.h>
206
+ #include <ATen/ops/is_conj_ops.h>
207
+ #include <ATen/ops/is_distributed_ops.h>
208
+ #include <ATen/ops/is_floating_point_ops.h>
209
+ #include <ATen/ops/is_inference_ops.h>
210
+ #include <ATen/ops/is_leaf_ops.h>
211
+ #include <ATen/ops/is_neg_ops.h>
212
+ #include <ATen/ops/is_nonzero_ops.h>
213
+ #include <ATen/ops/is_pinned_ops.h>
214
+ #include <ATen/ops/is_same_size_ops.h>
215
+ #include <ATen/ops/is_set_to_ops.h>
216
+ #include <ATen/ops/is_signed_ops.h>
217
+ #include <ATen/ops/isclose_ops.h>
218
+ #include <ATen/ops/isfinite_ops.h>
219
+ #include <ATen/ops/isinf_ops.h>
220
+ #include <ATen/ops/isnan_ops.h>
221
+ #include <ATen/ops/isneginf_ops.h>
222
+ #include <ATen/ops/isposinf_ops.h>
223
+ #include <ATen/ops/isreal_ops.h>
224
+ #include <ATen/ops/istft_ops.h>
225
+ #include <ATen/ops/item_ops.h>
226
+ #include <ATen/ops/kron_ops.h>
227
+ #include <ATen/ops/kthvalue_ops.h>
228
+ #include <ATen/ops/lcm_ops.h>
229
+ #include <ATen/ops/ldexp_ops.h>
230
+ #include <ATen/ops/le_ops.h>
231
+ #include <ATen/ops/lerp_ops.h>
232
+ #include <ATen/ops/less_equal_ops.h>
233
+ #include <ATen/ops/less_ops.h>
234
+ #include <ATen/ops/lgamma_ops.h>
235
+ #include <ATen/ops/log10_ops.h>
236
+ #include <ATen/ops/log1p_ops.h>
237
+ #include <ATen/ops/log2_ops.h>
238
+ #include <ATen/ops/log_normal_ops.h>
239
+ #include <ATen/ops/log_ops.h>
240
+ #include <ATen/ops/log_softmax_ops.h>
241
+ #include <ATen/ops/logaddexp2_ops.h>
242
+ #include <ATen/ops/logaddexp_ops.h>
243
+ #include <ATen/ops/logcumsumexp_ops.h>
244
+ #include <ATen/ops/logdet_ops.h>
245
+ #include <ATen/ops/logical_and_ops.h>
246
+ #include <ATen/ops/logical_not_ops.h>
247
+ #include <ATen/ops/logical_or_ops.h>
248
+ #include <ATen/ops/logical_xor_ops.h>
249
+ #include <ATen/ops/logit_ops.h>
250
+ #include <ATen/ops/logsumexp_ops.h>
251
+ #include <ATen/ops/lshift_ops.h>
252
+ #include <ATen/ops/lt_ops.h>
253
+ #include <ATen/ops/lu_solve_ops.h>
254
+ #include <ATen/ops/mH_ops.h>
255
+ #include <ATen/ops/mT_ops.h>
256
+ #include <ATen/ops/masked_fill_ops.h>
257
+ #include <ATen/ops/masked_scatter_ops.h>
258
+ #include <ATen/ops/masked_select_ops.h>
259
+ #include <ATen/ops/matmul_ops.h>
260
+ #include <ATen/ops/matrix_H_ops.h>
261
+ #include <ATen/ops/matrix_exp_ops.h>
262
+ #include <ATen/ops/matrix_power_ops.h>
263
+ #include <ATen/ops/max_ops.h>
264
+ #include <ATen/ops/maximum_ops.h>
265
+ #include <ATen/ops/mean_ops.h>
266
+ #include <ATen/ops/median_ops.h>
267
+ #include <ATen/ops/min_ops.h>
268
+ #include <ATen/ops/minimum_ops.h>
269
+ #include <ATen/ops/mm_ops.h>
270
+ #include <ATen/ops/mode_ops.h>
271
+ #include <ATen/ops/moveaxis_ops.h>
272
+ #include <ATen/ops/movedim_ops.h>
273
+ #include <ATen/ops/msort_ops.h>
274
+ #include <ATen/ops/mul_ops.h>
275
+ #include <ATen/ops/multinomial_ops.h>
276
+ #include <ATen/ops/multiply_ops.h>
277
+ #include <ATen/ops/mv_ops.h>
278
+ #include <ATen/ops/mvlgamma_ops.h>
279
+ #include <ATen/ops/nan_to_num_ops.h>
280
+ #include <ATen/ops/nanmean_ops.h>
281
+ #include <ATen/ops/nanmedian_ops.h>
282
+ #include <ATen/ops/nanquantile_ops.h>
283
+ #include <ATen/ops/nansum_ops.h>
284
+ #include <ATen/ops/narrow_copy_ops.h>
285
+ #include <ATen/ops/narrow_ops.h>
286
+ #include <ATen/ops/ne_ops.h>
287
+ #include <ATen/ops/neg_ops.h>
288
+ #include <ATen/ops/negative_ops.h>
289
+ #include <ATen/ops/new_empty_ops.h>
290
+ #include <ATen/ops/new_empty_strided_ops.h>
291
+ #include <ATen/ops/new_full_ops.h>
292
+ #include <ATen/ops/new_ones_ops.h>
293
+ #include <ATen/ops/new_zeros_ops.h>
294
+ #include <ATen/ops/nextafter_ops.h>
295
+ #include <ATen/ops/nonzero_numpy_ops.h>
296
+ #include <ATen/ops/nonzero_ops.h>
297
+ #include <ATen/ops/nonzero_static_ops.h>
298
+ #include <ATen/ops/norm_ops.h>
299
+ #include <ATen/ops/normal_ops.h>
300
+ #include <ATen/ops/not_equal_ops.h>
301
+ #include <ATen/ops/numpy_T_ops.h>
302
+ #include <ATen/ops/or_ops.h>
303
+ #include <ATen/ops/orgqr_ops.h>
304
+ #include <ATen/ops/ormqr_ops.h>
305
+ #include <ATen/ops/outer_ops.h>
306
+ #include <ATen/ops/output_nr_ops.h>
307
+ #include <ATen/ops/permute_ops.h>
308
+ #include <ATen/ops/pin_memory_ops.h>
309
+ #include <ATen/ops/pinverse_ops.h>
310
+ #include <ATen/ops/polygamma_ops.h>
311
+ #include <ATen/ops/positive_ops.h>
312
+ #include <ATen/ops/pow_ops.h>
313
+ #include <ATen/ops/prelu_ops.h>
314
+ #include <ATen/ops/prod_ops.h>
315
+ #include <ATen/ops/put_ops.h>
316
+ #include <ATen/ops/q_per_channel_axis_ops.h>
317
+ #include <ATen/ops/q_per_channel_scales_ops.h>
318
+ #include <ATen/ops/q_per_channel_zero_points_ops.h>
319
+ #include <ATen/ops/q_scale_ops.h>
320
+ #include <ATen/ops/q_zero_point_ops.h>
321
+ #include <ATen/ops/qr_ops.h>
322
+ #include <ATen/ops/qscheme_ops.h>
323
+ #include <ATen/ops/quantile_ops.h>
324
+ #include <ATen/ops/rad2deg_ops.h>
325
+ #include <ATen/ops/random_ops.h>
326
+ #include <ATen/ops/ravel_ops.h>
327
+ #include <ATen/ops/reciprocal_ops.h>
328
+ #include <ATen/ops/record_stream_ops.h>
329
+ #include <ATen/ops/refine_names_ops.h>
330
+ #include <ATen/ops/relu_ops.h>
331
+ #include <ATen/ops/remainder_ops.h>
332
+ #include <ATen/ops/rename_ops.h>
333
+ #include <ATen/ops/renorm_ops.h>
334
+ #include <ATen/ops/repeat_interleave_ops.h>
335
+ #include <ATen/ops/repeat_ops.h>
336
+ #include <ATen/ops/requires_grad_ops.h>
337
+ #include <ATen/ops/reshape_as_ops.h>
338
+ #include <ATen/ops/reshape_ops.h>
339
+ #include <ATen/ops/resize_as_ops.h>
340
+ #include <ATen/ops/resize_as_sparse_ops.h>
341
+ #include <ATen/ops/resize_ops.h>
342
+ #include <ATen/ops/resolve_conj_ops.h>
343
+ #include <ATen/ops/resolve_neg_ops.h>
344
+ #include <ATen/ops/retain_grad_ops.h>
345
+ #include <ATen/ops/retains_grad_ops.h>
346
+ #include <ATen/ops/roll_ops.h>
347
+ #include <ATen/ops/rot90_ops.h>
348
+ #include <ATen/ops/round_ops.h>
349
+ #include <ATen/ops/row_indices_ops.h>
350
+ #include <ATen/ops/rshift_ops.h>
351
+ #include <ATen/ops/rsqrt_ops.h>
352
+ #include <ATen/ops/scatter_add_ops.h>
353
+ #include <ATen/ops/scatter_ops.h>
354
+ #include <ATen/ops/scatter_reduce_ops.h>
355
+ #include <ATen/ops/select_ops.h>
356
+ #include <ATen/ops/select_scatter_ops.h>
357
+ #include <ATen/ops/set_data_ops.h>
358
+ #include <ATen/ops/set_ops.h>
359
+ #include <ATen/ops/sgn_ops.h>
360
+ #include <ATen/ops/sigmoid_ops.h>
361
+ #include <ATen/ops/sign_ops.h>
362
+ #include <ATen/ops/signbit_ops.h>
363
+ #include <ATen/ops/sin_ops.h>
364
+ #include <ATen/ops/sinc_ops.h>
365
+ #include <ATen/ops/sinh_ops.h>
366
+ #include <ATen/ops/size_ops.h>
367
+ #include <ATen/ops/slice_ops.h>
368
+ #include <ATen/ops/slice_scatter_ops.h>
369
+ #include <ATen/ops/slogdet_ops.h>
370
+ #include <ATen/ops/smm_ops.h>
371
+ #include <ATen/ops/softmax_ops.h>
372
+ #include <ATen/ops/sort_ops.h>
373
+ #include <ATen/ops/sparse_dim_ops.h>
374
+ #include <ATen/ops/sparse_mask_ops.h>
375
+ #include <ATen/ops/sparse_resize_and_clear_ops.h>
376
+ #include <ATen/ops/sparse_resize_ops.h>
377
+ #include <ATen/ops/split_ops.h>
378
+ #include <ATen/ops/split_with_sizes_ops.h>
379
+ #include <ATen/ops/sqrt_ops.h>
380
+ #include <ATen/ops/square_ops.h>
381
+ #include <ATen/ops/squeeze_ops.h>
382
+ #include <ATen/ops/sspaddmm_ops.h>
383
+ #include <ATen/ops/std_ops.h>
384
+ #include <ATen/ops/stft_ops.h>
385
+ #include <ATen/ops/stride_ops.h>
386
+ #include <ATen/ops/sub_ops.h>
387
+ #include <ATen/ops/subtract_ops.h>
388
+ #include <ATen/ops/sum_ops.h>
389
+ #include <ATen/ops/sum_to_size_ops.h>
390
+ #include <ATen/ops/svd_ops.h>
391
+ #include <ATen/ops/swapaxes_ops.h>
392
+ #include <ATen/ops/swapdims_ops.h>
393
+ #include <ATen/ops/t_ops.h>
394
+ #include <ATen/ops/take_along_dim_ops.h>
395
+ #include <ATen/ops/take_ops.h>
396
+ #include <ATen/ops/tan_ops.h>
397
+ #include <ATen/ops/tanh_ops.h>
398
+ #include <ATen/ops/tensor_split_ops.h>
399
+ #include <ATen/ops/tile_ops.h>
400
+ #include <ATen/ops/to_dense_ops.h>
401
+ #include <ATen/ops/to_mkldnn_ops.h>
402
+ #include <ATen/ops/to_ops.h>
403
+ #include <ATen/ops/to_padded_tensor_ops.h>
404
+ #include <ATen/ops/to_sparse_bsc_ops.h>
405
+ #include <ATen/ops/to_sparse_bsr_ops.h>
406
+ #include <ATen/ops/to_sparse_csc_ops.h>
407
+ #include <ATen/ops/to_sparse_csr_ops.h>
408
+ #include <ATen/ops/to_sparse_ops.h>
409
+ #include <ATen/ops/topk_ops.h>
410
+ #include <ATen/ops/trace_ops.h>
411
+ #include <ATen/ops/transpose_ops.h>
412
+ #include <ATen/ops/triangular_solve_ops.h>
413
+ #include <ATen/ops/tril_ops.h>
414
+ #include <ATen/ops/triu_ops.h>
415
+ #include <ATen/ops/true_divide_ops.h>
416
+ #include <ATen/ops/trunc_ops.h>
417
+ #include <ATen/ops/type_as_ops.h>
418
+ #include <ATen/ops/unbind_ops.h>
419
+ #include <ATen/ops/unflatten_ops.h>
420
+ #include <ATen/ops/unfold_ops.h>
421
+ #include <ATen/ops/uniform_ops.h>
422
+ #include <ATen/ops/unsafe_chunk_ops.h>
423
+ #include <ATen/ops/unsafe_split_ops.h>
424
+ #include <ATen/ops/unsafe_split_with_sizes_ops.h>
425
+ #include <ATen/ops/unsqueeze_ops.h>
426
+ #include <ATen/ops/values_ops.h>
427
+ #include <ATen/ops/var_ops.h>
428
+ #include <ATen/ops/vdot_ops.h>
429
+ #include <ATen/ops/view_as_ops.h>
430
+ #include <ATen/ops/view_ops.h>
431
+ #include <ATen/ops/vsplit_ops.h>
432
+ #include <ATen/ops/where_ops.h>
433
+ #include <ATen/ops/xlogy_ops.h>
434
+ #include <ATen/ops/xor_ops.h>
435
+ #include <ATen/ops/zero_ops.h>
436
+
437
+ namespace at {
438
+ namespace _ops {
439
+
440
+ } // namespace _ops
441
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/NamedTensor.h ADDED
@@ -0,0 +1 @@
 
 
1
+ #include <ATen/core/NamedTensor.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/NativeFunctions.h ADDED
@@ -0,0 +1,1295 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunctions.h
4
+
5
+ #ifdef TORCH_ASSERT_NO_OPERATORS
6
+ #error This change adds a dependency on native_functions.yaml, \
7
+ meaning the file will need to be re-compiled every time an operator \
8
+ is changed or added. Consider if your change would be better placed in \
9
+ another file, or if a more specific header might achieve the same goal. \
10
+ See NOTE: [Tensor vs. TensorBase]
11
+ #endif
12
+
13
+ #if defined(AT_PER_OPERATOR_HEADERS) && defined(TORCH_ASSERT_ONLY_METHOD_OPERATORS)
14
+ #error This change adds a dependency on all pytorch operators, meaning the \
15
+ file will need to be re-compiled every time an operator is changed or added. \
16
+ Consider including a specific operator from <ATen/ops/{my_operator}_native.h> \
17
+ and see NOTE [TORCH_ASSERT_ONLY_METHOD_OPERATORS].
18
+ #endif
19
+
20
+ #include <c10/core/Scalar.h>
21
+ #include <c10/core/Storage.h>
22
+ #include <c10/core/TensorOptions.h>
23
+ #include <c10/util/Deprecated.h>
24
+ #include <c10/util/Optional.h>
25
+ #include <c10/core/QScheme.h>
26
+ #include <ATen/core/Reduction.h>
27
+ #include <ATen/core/Tensor.h>
28
+ #include <tuple>
29
+ #include <vector>
30
+
31
+ #include <ATen/ops/_adaptive_avg_pool2d_native.h>
32
+ #include <ATen/ops/_adaptive_avg_pool2d_backward_native.h>
33
+ #include <ATen/ops/_adaptive_avg_pool3d_native.h>
34
+ #include <ATen/ops/_adaptive_avg_pool3d_backward_native.h>
35
+ #include <ATen/ops/_add_batch_dim_native.h>
36
+ #include <ATen/ops/_add_relu_native.h>
37
+ #include <ATen/ops/_addmm_activation_native.h>
38
+ #include <ATen/ops/_aminmax_native.h>
39
+ #include <ATen/ops/_amp_foreach_non_finite_check_and_unscale_native.h>
40
+ #include <ATen/ops/_amp_update_scale_native.h>
41
+ #include <ATen/ops/_assert_async_native.h>
42
+ #include <ATen/ops/_assert_tensor_metadata_native.h>
43
+ #include <ATen/ops/_autocast_to_full_precision_native.h>
44
+ #include <ATen/ops/_autocast_to_reduced_precision_native.h>
45
+ #include <ATen/ops/_backward_native.h>
46
+ #include <ATen/ops/_batch_norm_impl_index_native.h>
47
+ #include <ATen/ops/_batch_norm_impl_index_backward_native.h>
48
+ #include <ATen/ops/_cast_Byte_native.h>
49
+ #include <ATen/ops/_cast_Char_native.h>
50
+ #include <ATen/ops/_cast_Double_native.h>
51
+ #include <ATen/ops/_cast_Float_native.h>
52
+ #include <ATen/ops/_cast_Half_native.h>
53
+ #include <ATen/ops/_cast_Int_native.h>
54
+ #include <ATen/ops/_cast_Long_native.h>
55
+ #include <ATen/ops/_cast_Short_native.h>
56
+ #include <ATen/ops/_cdist_backward_native.h>
57
+ #include <ATen/ops/_cdist_forward_native.h>
58
+ #include <ATen/ops/_cholesky_solve_helper_native.h>
59
+ #include <ATen/ops/_choose_qparams_per_tensor_native.h>
60
+ #include <ATen/ops/_coalesce_native.h>
61
+ #include <ATen/ops/_coalesced_native.h>
62
+ #include <ATen/ops/_compute_linear_combination_native.h>
63
+ #include <ATen/ops/_conj_native.h>
64
+ #include <ATen/ops/_conj_copy_native.h>
65
+ #include <ATen/ops/_conj_physical_native.h>
66
+ #include <ATen/ops/_conv_depthwise2d_native.h>
67
+ #include <ATen/ops/_convert_indices_from_coo_to_csr_native.h>
68
+ #include <ATen/ops/_convert_indices_from_csr_to_coo_native.h>
69
+ #include <ATen/ops/_convert_weight_to_int4pack_native.h>
70
+ #include <ATen/ops/_convolution_native.h>
71
+ #include <ATen/ops/_convolution_double_backward_native.h>
72
+ #include <ATen/ops/_convolution_mode_native.h>
73
+ #include <ATen/ops/_copy_from_native.h>
74
+ #include <ATen/ops/_copy_from_and_resize_native.h>
75
+ #include <ATen/ops/_cslt_compress_native.h>
76
+ #include <ATen/ops/_cslt_sparse_mm_native.h>
77
+ #include <ATen/ops/_ctc_loss_native.h>
78
+ #include <ATen/ops/_ctc_loss_backward_native.h>
79
+ #include <ATen/ops/_cudnn_ctc_loss_native.h>
80
+ #include <ATen/ops/_cudnn_init_dropout_state_native.h>
81
+ #include <ATen/ops/_cudnn_rnn_native.h>
82
+ #include <ATen/ops/_cudnn_rnn_backward_native.h>
83
+ #include <ATen/ops/_cudnn_rnn_flatten_weight_native.h>
84
+ #include <ATen/ops/_cufft_clear_plan_cache_native.h>
85
+ #include <ATen/ops/_cufft_get_plan_cache_max_size_native.h>
86
+ #include <ATen/ops/_cufft_get_plan_cache_size_native.h>
87
+ #include <ATen/ops/_cufft_set_plan_cache_max_size_native.h>
88
+ #include <ATen/ops/_cummax_helper_native.h>
89
+ #include <ATen/ops/_cummin_helper_native.h>
90
+ #include <ATen/ops/_debug_has_internal_overlap_native.h>
91
+ #include <ATen/ops/_dimI_native.h>
92
+ #include <ATen/ops/_dimV_native.h>
93
+ #include <ATen/ops/_dim_arange_native.h>
94
+ #include <ATen/ops/_dirichlet_grad_native.h>
95
+ #include <ATen/ops/_efficient_attention_backward_native.h>
96
+ #include <ATen/ops/_efficient_attention_forward_native.h>
97
+ #include <ATen/ops/_efficientzerotensor_native.h>
98
+ #include <ATen/ops/_embedding_bag_native.h>
99
+ #include <ATen/ops/_embedding_bag_backward_native.h>
100
+ #include <ATen/ops/_embedding_bag_dense_backward_native.h>
101
+ #include <ATen/ops/_embedding_bag_forward_only_native.h>
102
+ #include <ATen/ops/_embedding_bag_per_sample_weights_backward_native.h>
103
+ #include <ATen/ops/_embedding_bag_sparse_backward_native.h>
104
+ #include <ATen/ops/_empty_affine_quantized_native.h>
105
+ #include <ATen/ops/_empty_per_channel_affine_quantized_native.h>
106
+ #include <ATen/ops/_euclidean_dist_native.h>
107
+ #include <ATen/ops/_fake_quantize_learnable_per_channel_affine_native.h>
108
+ #include <ATen/ops/_fake_quantize_learnable_per_channel_affine_backward_native.h>
109
+ #include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_native.h>
110
+ #include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward_native.h>
111
+ #include <ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_native.h>
112
+ #include <ATen/ops/_fft_c2c_native.h>
113
+ #include <ATen/ops/_fft_c2r_native.h>
114
+ #include <ATen/ops/_fft_r2c_native.h>
115
+ #include <ATen/ops/_fill_mem_eff_dropout_mask_native.h>
116
+ #include <ATen/ops/_flash_attention_backward_native.h>
117
+ #include <ATen/ops/_flash_attention_forward_native.h>
118
+ #include <ATen/ops/_foobar_native.h>
119
+ #include <ATen/ops/_foreach_abs_native.h>
120
+ #include <ATen/ops/_foreach_acos_native.h>
121
+ #include <ATen/ops/_foreach_add_native.h>
122
+ #include <ATen/ops/_foreach_addcdiv_native.h>
123
+ #include <ATen/ops/_foreach_addcmul_native.h>
124
+ #include <ATen/ops/_foreach_asin_native.h>
125
+ #include <ATen/ops/_foreach_atan_native.h>
126
+ #include <ATen/ops/_foreach_ceil_native.h>
127
+ #include <ATen/ops/_foreach_clamp_max_native.h>
128
+ #include <ATen/ops/_foreach_clamp_min_native.h>
129
+ #include <ATen/ops/_foreach_copy_native.h>
130
+ #include <ATen/ops/_foreach_cos_native.h>
131
+ #include <ATen/ops/_foreach_cosh_native.h>
132
+ #include <ATen/ops/_foreach_div_native.h>
133
+ #include <ATen/ops/_foreach_erf_native.h>
134
+ #include <ATen/ops/_foreach_erfc_native.h>
135
+ #include <ATen/ops/_foreach_exp_native.h>
136
+ #include <ATen/ops/_foreach_expm1_native.h>
137
+ #include <ATen/ops/_foreach_floor_native.h>
138
+ #include <ATen/ops/_foreach_frac_native.h>
139
+ #include <ATen/ops/_foreach_lerp_native.h>
140
+ #include <ATen/ops/_foreach_lgamma_native.h>
141
+ #include <ATen/ops/_foreach_log_native.h>
142
+ #include <ATen/ops/_foreach_log10_native.h>
143
+ #include <ATen/ops/_foreach_log1p_native.h>
144
+ #include <ATen/ops/_foreach_log2_native.h>
145
+ #include <ATen/ops/_foreach_maximum_native.h>
146
+ #include <ATen/ops/_foreach_minimum_native.h>
147
+ #include <ATen/ops/_foreach_mul_native.h>
148
+ #include <ATen/ops/_foreach_neg_native.h>
149
+ #include <ATen/ops/_foreach_norm_native.h>
150
+ #include <ATen/ops/_foreach_pow_native.h>
151
+ #include <ATen/ops/_foreach_reciprocal_native.h>
152
+ #include <ATen/ops/_foreach_round_native.h>
153
+ #include <ATen/ops/_foreach_sigmoid_native.h>
154
+ #include <ATen/ops/_foreach_sign_native.h>
155
+ #include <ATen/ops/_foreach_sin_native.h>
156
+ #include <ATen/ops/_foreach_sinh_native.h>
157
+ #include <ATen/ops/_foreach_sqrt_native.h>
158
+ #include <ATen/ops/_foreach_sub_native.h>
159
+ #include <ATen/ops/_foreach_tan_native.h>
160
+ #include <ATen/ops/_foreach_tanh_native.h>
161
+ #include <ATen/ops/_foreach_trunc_native.h>
162
+ #include <ATen/ops/_foreach_zero_native.h>
163
+ #include <ATen/ops/_functional_assert_async_native.h>
164
+ #include <ATen/ops/_functional_sym_constrain_range_native.h>
165
+ #include <ATen/ops/_functional_sym_constrain_range_for_size_native.h>
166
+ #include <ATen/ops/_fused_adam_native.h>
167
+ #include <ATen/ops/_fused_adamw_native.h>
168
+ #include <ATen/ops/_fused_dropout_native.h>
169
+ #include <ATen/ops/_fused_moving_avg_obs_fq_helper_native.h>
170
+ #include <ATen/ops/_fused_sdp_choice_native.h>
171
+ #include <ATen/ops/_fw_primal_native.h>
172
+ #include <ATen/ops/_fw_primal_copy_native.h>
173
+ #include <ATen/ops/_gather_sparse_backward_native.h>
174
+ #include <ATen/ops/_grid_sampler_2d_cpu_fallback_native.h>
175
+ #include <ATen/ops/_grid_sampler_2d_cpu_fallback_backward_native.h>
176
+ #include <ATen/ops/_has_compatible_shallow_copy_type_native.h>
177
+ #include <ATen/ops/_has_same_storage_numel_native.h>
178
+ #include <ATen/ops/_histogramdd_bin_edges_native.h>
179
+ #include <ATen/ops/_histogramdd_from_bin_cts_native.h>
180
+ #include <ATen/ops/_histogramdd_from_bin_tensors_native.h>
181
+ #include <ATen/ops/_index_put_impl_native.h>
182
+ #include <ATen/ops/_indices_native.h>
183
+ #include <ATen/ops/_indices_copy_native.h>
184
+ #include <ATen/ops/_int_mm_native.h>
185
+ #include <ATen/ops/_is_all_true_native.h>
186
+ #include <ATen/ops/_is_any_true_native.h>
187
+ #include <ATen/ops/_is_zerotensor_native.h>
188
+ #include <ATen/ops/_linalg_check_errors_native.h>
189
+ #include <ATen/ops/_linalg_det_native.h>
190
+ #include <ATen/ops/_linalg_eigh_native.h>
191
+ #include <ATen/ops/_linalg_slogdet_native.h>
192
+ #include <ATen/ops/_linalg_solve_ex_native.h>
193
+ #include <ATen/ops/_linalg_svd_native.h>
194
+ #include <ATen/ops/_local_scalar_dense_native.h>
195
+ #include <ATen/ops/_log_softmax_native.h>
196
+ #include <ATen/ops/_log_softmax_backward_data_native.h>
197
+ #include <ATen/ops/_logcumsumexp_native.h>
198
+ #include <ATen/ops/_lstm_mps_native.h>
199
+ #include <ATen/ops/_lu_with_info_native.h>
200
+ #include <ATen/ops/_make_dep_token_native.h>
201
+ #include <ATen/ops/_make_dual_native.h>
202
+ #include <ATen/ops/_make_dual_copy_native.h>
203
+ #include <ATen/ops/_make_per_channel_quantized_tensor_native.h>
204
+ #include <ATen/ops/_make_per_tensor_quantized_tensor_native.h>
205
+ #include <ATen/ops/_masked_scale_native.h>
206
+ #include <ATen/ops/_masked_softmax_native.h>
207
+ #include <ATen/ops/_masked_softmax_backward_native.h>
208
+ #include <ATen/ops/_mixed_dtypes_linear_native.h>
209
+ #include <ATen/ops/_mkldnn_reshape_native.h>
210
+ #include <ATen/ops/_mkldnn_transpose_native.h>
211
+ #include <ATen/ops/_mps_convolution_native.h>
212
+ #include <ATen/ops/_mps_convolution_transpose_native.h>
213
+ #include <ATen/ops/_native_batch_norm_legit_native.h>
214
+ #include <ATen/ops/_native_batch_norm_legit_no_training_native.h>
215
+ #include <ATen/ops/_native_multi_head_attention_native.h>
216
+ #include <ATen/ops/_neg_view_native.h>
217
+ #include <ATen/ops/_neg_view_copy_native.h>
218
+ #include <ATen/ops/_nested_from_padded_native.h>
219
+ #include <ATen/ops/_nested_from_padded_and_nested_example_native.h>
220
+ #include <ATen/ops/_nested_select_backward_native.h>
221
+ #include <ATen/ops/_nested_sum_backward_native.h>
222
+ #include <ATen/ops/_nested_tensor_from_mask_native.h>
223
+ #include <ATen/ops/_nested_tensor_from_mask_left_aligned_native.h>
224
+ #include <ATen/ops/_nested_tensor_from_tensor_list_native.h>
225
+ #include <ATen/ops/_nested_tensor_size_native.h>
226
+ #include <ATen/ops/_nested_tensor_softmax_with_shape_native.h>
227
+ #include <ATen/ops/_nested_tensor_storage_offsets_native.h>
228
+ #include <ATen/ops/_nested_tensor_strides_native.h>
229
+ #include <ATen/ops/_nested_view_from_buffer_native.h>
230
+ #include <ATen/ops/_nested_view_from_buffer_copy_native.h>
231
+ #include <ATen/ops/_new_zeros_with_same_feature_meta_native.h>
232
+ #include <ATen/ops/_nnpack_available_native.h>
233
+ #include <ATen/ops/_nnpack_spatial_convolution_native.h>
234
+ #include <ATen/ops/_nnz_native.h>
235
+ #include <ATen/ops/_pack_padded_sequence_native.h>
236
+ #include <ATen/ops/_pack_padded_sequence_backward_native.h>
237
+ #include <ATen/ops/_pad_circular_native.h>
238
+ #include <ATen/ops/_pad_enum_native.h>
239
+ #include <ATen/ops/_pad_packed_sequence_native.h>
240
+ #include <ATen/ops/_pdist_backward_native.h>
241
+ #include <ATen/ops/_pdist_forward_native.h>
242
+ #include <ATen/ops/_pin_memory_native.h>
243
+ #include <ATen/ops/_prelu_kernel_native.h>
244
+ #include <ATen/ops/_prelu_kernel_backward_native.h>
245
+ #include <ATen/ops/_propagate_xla_data_native.h>
246
+ #include <ATen/ops/_remove_batch_dim_native.h>
247
+ #include <ATen/ops/_reshape_alias_native.h>
248
+ #include <ATen/ops/_reshape_alias_copy_native.h>
249
+ #include <ATen/ops/_reshape_copy_native.h>
250
+ #include <ATen/ops/_reshape_from_tensor_native.h>
251
+ #include <ATen/ops/_resize_output_native.h>
252
+ #include <ATen/ops/_rowwise_prune_native.h>
253
+ #include <ATen/ops/_sample_dirichlet_native.h>
254
+ #include <ATen/ops/_saturate_weight_to_fp16_native.h>
255
+ #include <ATen/ops/_scaled_dot_product_attention_math_native.h>
256
+ #include <ATen/ops/_scaled_dot_product_efficient_attention_native.h>
257
+ #include <ATen/ops/_scaled_dot_product_efficient_attention_backward_native.h>
258
+ #include <ATen/ops/_scaled_dot_product_flash_attention_native.h>
259
+ #include <ATen/ops/_scaled_dot_product_flash_attention_backward_native.h>
260
+ #include <ATen/ops/_scaled_mm_native.h>
261
+ #include <ATen/ops/_segment_reduce_backward_native.h>
262
+ #include <ATen/ops/_shape_as_tensor_native.h>
263
+ #include <ATen/ops/_slow_conv2d_backward_native.h>
264
+ #include <ATen/ops/_slow_conv2d_forward_native.h>
265
+ #include <ATen/ops/_sobol_engine_draw_native.h>
266
+ #include <ATen/ops/_sobol_engine_ff_native.h>
267
+ #include <ATen/ops/_sobol_engine_initialize_state_native.h>
268
+ #include <ATen/ops/_sobol_engine_scramble_native.h>
269
+ #include <ATen/ops/_softmax_native.h>
270
+ #include <ATen/ops/_softmax_backward_data_native.h>
271
+ #include <ATen/ops/_sparse_addmm_native.h>
272
+ #include <ATen/ops/_sparse_broadcast_to_native.h>
273
+ #include <ATen/ops/_sparse_broadcast_to_copy_native.h>
274
+ #include <ATen/ops/_sparse_bsc_tensor_unsafe_native.h>
275
+ #include <ATen/ops/_sparse_bsr_tensor_unsafe_native.h>
276
+ #include <ATen/ops/_sparse_compressed_tensor_unsafe_native.h>
277
+ #include <ATen/ops/_sparse_coo_tensor_unsafe_native.h>
278
+ #include <ATen/ops/_sparse_coo_tensor_with_dims_native.h>
279
+ #include <ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_native.h>
280
+ #include <ATen/ops/_sparse_csc_tensor_unsafe_native.h>
281
+ #include <ATen/ops/_sparse_csr_prod_native.h>
282
+ #include <ATen/ops/_sparse_csr_sum_native.h>
283
+ #include <ATen/ops/_sparse_csr_tensor_unsafe_native.h>
284
+ #include <ATen/ops/_sparse_log_softmax_native.h>
285
+ #include <ATen/ops/_sparse_log_softmax_backward_data_native.h>
286
+ #include <ATen/ops/_sparse_mask_projection_native.h>
287
+ #include <ATen/ops/_sparse_mm_native.h>
288
+ #include <ATen/ops/_sparse_mm_reduce_impl_native.h>
289
+ #include <ATen/ops/_sparse_mm_reduce_impl_backward_native.h>
290
+ #include <ATen/ops/_sparse_semi_structured_linear_native.h>
291
+ #include <ATen/ops/_sparse_softmax_native.h>
292
+ #include <ATen/ops/_sparse_softmax_backward_data_native.h>
293
+ #include <ATen/ops/_sparse_sparse_matmul_native.h>
294
+ #include <ATen/ops/_sparse_sum_native.h>
295
+ #include <ATen/ops/_sparse_sum_backward_native.h>
296
+ #include <ATen/ops/_spdiags_native.h>
297
+ #include <ATen/ops/_stack_native.h>
298
+ #include <ATen/ops/_standard_gamma_native.h>
299
+ #include <ATen/ops/_standard_gamma_grad_native.h>
300
+ #include <ATen/ops/_test_ambiguous_defaults_native.h>
301
+ #include <ATen/ops/_test_autograd_multiple_dispatch_native.h>
302
+ #include <ATen/ops/_test_autograd_multiple_dispatch_view_native.h>
303
+ #include <ATen/ops/_test_autograd_multiple_dispatch_view_copy_native.h>
304
+ #include <ATen/ops/_test_check_tensor_native.h>
305
+ #include <ATen/ops/_test_functorch_fallback_native.h>
306
+ #include <ATen/ops/_test_optional_filled_intlist_native.h>
307
+ #include <ATen/ops/_test_optional_floatlist_native.h>
308
+ #include <ATen/ops/_test_optional_intlist_native.h>
309
+ #include <ATen/ops/_test_serialization_subcmul_native.h>
310
+ #include <ATen/ops/_test_string_default_native.h>
311
+ #include <ATen/ops/_test_warn_in_autograd_native.h>
312
+ #include <ATen/ops/_thnn_differentiable_gru_cell_backward_native.h>
313
+ #include <ATen/ops/_thnn_differentiable_lstm_cell_backward_native.h>
314
+ #include <ATen/ops/_thnn_fused_gru_cell_native.h>
315
+ #include <ATen/ops/_thnn_fused_gru_cell_backward_native.h>
316
+ #include <ATen/ops/_thnn_fused_lstm_cell_native.h>
317
+ #include <ATen/ops/_thnn_fused_lstm_cell_backward_native.h>
318
+ #include <ATen/ops/_thnn_fused_lstm_cell_backward_impl_native.h>
319
+ #include <ATen/ops/_to_copy_native.h>
320
+ #include <ATen/ops/_to_cpu_native.h>
321
+ #include <ATen/ops/_to_dense_native.h>
322
+ #include <ATen/ops/_to_sparse_native.h>
323
+ #include <ATen/ops/_to_sparse_bsc_native.h>
324
+ #include <ATen/ops/_to_sparse_bsr_native.h>
325
+ #include <ATen/ops/_to_sparse_csc_native.h>
326
+ #include <ATen/ops/_to_sparse_csr_native.h>
327
+ #include <ATen/ops/_to_sparse_semi_structured_native.h>
328
+ #include <ATen/ops/_transform_bias_rescale_qkv_native.h>
329
+ #include <ATen/ops/_transformer_encoder_layer_fwd_native.h>
330
+ #include <ATen/ops/_trilinear_native.h>
331
+ #include <ATen/ops/_triton_multi_head_attention_native.h>
332
+ #include <ATen/ops/_triton_scaled_dot_attention_native.h>
333
+ #include <ATen/ops/_unique_native.h>
334
+ #include <ATen/ops/_unique2_native.h>
335
+ #include <ATen/ops/_unpack_dual_native.h>
336
+ #include <ATen/ops/_unsafe_index_native.h>
337
+ #include <ATen/ops/_unsafe_index_put_native.h>
338
+ #include <ATen/ops/_unsafe_view_native.h>
339
+ #include <ATen/ops/_upsample_bicubic2d_aa_native.h>
340
+ #include <ATen/ops/_upsample_bicubic2d_aa_backward_native.h>
341
+ #include <ATen/ops/_upsample_bilinear2d_aa_native.h>
342
+ #include <ATen/ops/_upsample_bilinear2d_aa_backward_native.h>
343
+ #include <ATen/ops/_upsample_nearest_exact1d_native.h>
344
+ #include <ATen/ops/_upsample_nearest_exact1d_backward_native.h>
345
+ #include <ATen/ops/_upsample_nearest_exact2d_native.h>
346
+ #include <ATen/ops/_upsample_nearest_exact2d_backward_native.h>
347
+ #include <ATen/ops/_upsample_nearest_exact3d_native.h>
348
+ #include <ATen/ops/_upsample_nearest_exact3d_backward_native.h>
349
+ #include <ATen/ops/_use_cudnn_ctc_loss_native.h>
350
+ #include <ATen/ops/_use_cudnn_rnn_flatten_weight_native.h>
351
+ #include <ATen/ops/_validate_compressed_sparse_indices_native.h>
352
+ #include <ATen/ops/_validate_sparse_bsc_tensor_args_native.h>
353
+ #include <ATen/ops/_validate_sparse_bsr_tensor_args_native.h>
354
+ #include <ATen/ops/_validate_sparse_compressed_tensor_args_native.h>
355
+ #include <ATen/ops/_validate_sparse_coo_tensor_args_native.h>
356
+ #include <ATen/ops/_validate_sparse_csc_tensor_args_native.h>
357
+ #include <ATen/ops/_validate_sparse_csr_tensor_args_native.h>
358
+ #include <ATen/ops/_values_native.h>
359
+ #include <ATen/ops/_values_copy_native.h>
360
+ #include <ATen/ops/_version_native.h>
361
+ #include <ATen/ops/_weight_int4pack_mm_native.h>
362
+ #include <ATen/ops/_weight_norm_native.h>
363
+ #include <ATen/ops/_weight_norm_differentiable_backward_native.h>
364
+ #include <ATen/ops/_weight_norm_interface_native.h>
365
+ #include <ATen/ops/_weight_norm_interface_backward_native.h>
366
+ #include <ATen/ops/abs_native.h>
367
+ #include <ATen/ops/absolute_native.h>
368
+ #include <ATen/ops/acos_native.h>
369
+ #include <ATen/ops/acosh_native.h>
370
+ #include <ATen/ops/adaptive_avg_pool1d_native.h>
371
+ #include <ATen/ops/adaptive_avg_pool2d_native.h>
372
+ #include <ATen/ops/adaptive_avg_pool3d_native.h>
373
+ #include <ATen/ops/adaptive_avg_pool3d_backward_native.h>
374
+ #include <ATen/ops/adaptive_max_pool1d_native.h>
375
+ #include <ATen/ops/adaptive_max_pool2d_native.h>
376
+ #include <ATen/ops/adaptive_max_pool2d_backward_native.h>
377
+ #include <ATen/ops/adaptive_max_pool3d_native.h>
378
+ #include <ATen/ops/adaptive_max_pool3d_backward_native.h>
379
+ #include <ATen/ops/add_native.h>
380
+ #include <ATen/ops/addbmm_native.h>
381
+ #include <ATen/ops/addcdiv_native.h>
382
+ #include <ATen/ops/addcmul_native.h>
383
+ #include <ATen/ops/addmm_native.h>
384
+ #include <ATen/ops/addmv_native.h>
385
+ #include <ATen/ops/addr_native.h>
386
+ #include <ATen/ops/adjoint_native.h>
387
+ #include <ATen/ops/affine_grid_generator_native.h>
388
+ #include <ATen/ops/affine_grid_generator_backward_native.h>
389
+ #include <ATen/ops/alias_native.h>
390
+ #include <ATen/ops/alias_copy_native.h>
391
+ #include <ATen/ops/align_as_native.h>
392
+ #include <ATen/ops/align_tensors_native.h>
393
+ #include <ATen/ops/align_to_native.h>
394
+ #include <ATen/ops/all_native.h>
395
+ #include <ATen/ops/allclose_native.h>
396
+ #include <ATen/ops/alpha_dropout_native.h>
397
+ #include <ATen/ops/amax_native.h>
398
+ #include <ATen/ops/amin_native.h>
399
+ #include <ATen/ops/aminmax_native.h>
400
+ #include <ATen/ops/and_native.h>
401
+ #include <ATen/ops/angle_native.h>
402
+ #include <ATen/ops/any_native.h>
403
+ #include <ATen/ops/arange_native.h>
404
+ #include <ATen/ops/arccos_native.h>
405
+ #include <ATen/ops/arccosh_native.h>
406
+ #include <ATen/ops/arcsin_native.h>
407
+ #include <ATen/ops/arcsinh_native.h>
408
+ #include <ATen/ops/arctan_native.h>
409
+ #include <ATen/ops/arctan2_native.h>
410
+ #include <ATen/ops/arctanh_native.h>
411
+ #include <ATen/ops/argmax_native.h>
412
+ #include <ATen/ops/argmin_native.h>
413
+ #include <ATen/ops/argsort_native.h>
414
+ #include <ATen/ops/argwhere_native.h>
415
+ #include <ATen/ops/as_strided_native.h>
416
+ #include <ATen/ops/as_strided_copy_native.h>
417
+ #include <ATen/ops/as_strided_scatter_native.h>
418
+ #include <ATen/ops/asin_native.h>
419
+ #include <ATen/ops/asinh_native.h>
420
+ #include <ATen/ops/atan_native.h>
421
+ #include <ATen/ops/atan2_native.h>
422
+ #include <ATen/ops/atanh_native.h>
423
+ #include <ATen/ops/atleast_1d_native.h>
424
+ #include <ATen/ops/atleast_2d_native.h>
425
+ #include <ATen/ops/atleast_3d_native.h>
426
+ #include <ATen/ops/avg_pool1d_native.h>
427
+ #include <ATen/ops/avg_pool2d_native.h>
428
+ #include <ATen/ops/avg_pool2d_backward_native.h>
429
+ #include <ATen/ops/avg_pool3d_native.h>
430
+ #include <ATen/ops/avg_pool3d_backward_native.h>
431
+ #include <ATen/ops/baddbmm_native.h>
432
+ #include <ATen/ops/bartlett_window_native.h>
433
+ #include <ATen/ops/batch_norm_native.h>
434
+ #include <ATen/ops/batch_norm_backward_elemt_native.h>
435
+ #include <ATen/ops/batch_norm_backward_reduce_native.h>
436
+ #include <ATen/ops/batch_norm_elemt_native.h>
437
+ #include <ATen/ops/batch_norm_gather_stats_native.h>
438
+ #include <ATen/ops/batch_norm_gather_stats_with_counts_native.h>
439
+ #include <ATen/ops/batch_norm_stats_native.h>
440
+ #include <ATen/ops/batch_norm_update_stats_native.h>
441
+ #include <ATen/ops/bernoulli_native.h>
442
+ #include <ATen/ops/bilinear_native.h>
443
+ #include <ATen/ops/binary_cross_entropy_native.h>
444
+ #include <ATen/ops/binary_cross_entropy_backward_native.h>
445
+ #include <ATen/ops/binary_cross_entropy_with_logits_native.h>
446
+ #include <ATen/ops/bincount_native.h>
447
+ #include <ATen/ops/binomial_native.h>
448
+ #include <ATen/ops/bitwise_and_native.h>
449
+ #include <ATen/ops/bitwise_left_shift_native.h>
450
+ #include <ATen/ops/bitwise_not_native.h>
451
+ #include <ATen/ops/bitwise_or_native.h>
452
+ #include <ATen/ops/bitwise_right_shift_native.h>
453
+ #include <ATen/ops/bitwise_xor_native.h>
454
+ #include <ATen/ops/blackman_window_native.h>
455
+ #include <ATen/ops/block_diag_native.h>
456
+ #include <ATen/ops/bmm_native.h>
457
+ #include <ATen/ops/broadcast_tensors_native.h>
458
+ #include <ATen/ops/broadcast_to_native.h>
459
+ #include <ATen/ops/bucketize_native.h>
460
+ #include <ATen/ops/can_cast_native.h>
461
+ #include <ATen/ops/cartesian_prod_native.h>
462
+ #include <ATen/ops/cat_native.h>
463
+ #include <ATen/ops/cauchy_native.h>
464
+ #include <ATen/ops/ccol_indices_native.h>
465
+ #include <ATen/ops/ccol_indices_copy_native.h>
466
+ #include <ATen/ops/cdist_native.h>
467
+ #include <ATen/ops/ceil_native.h>
468
+ #include <ATen/ops/celu_native.h>
469
+ #include <ATen/ops/chain_matmul_native.h>
470
+ #include <ATen/ops/chalf_native.h>
471
+ #include <ATen/ops/channel_shuffle_native.h>
472
+ #include <ATen/ops/cholesky_native.h>
473
+ #include <ATen/ops/cholesky_inverse_native.h>
474
+ #include <ATen/ops/cholesky_solve_native.h>
475
+ #include <ATen/ops/choose_qparams_optimized_native.h>
476
+ #include <ATen/ops/chunk_native.h>
477
+ #include <ATen/ops/clamp_native.h>
478
+ #include <ATen/ops/clamp_max_native.h>
479
+ #include <ATen/ops/clamp_min_native.h>
480
+ #include <ATen/ops/clip_native.h>
481
+ #include <ATen/ops/clone_native.h>
482
+ #include <ATen/ops/coalesce_native.h>
483
+ #include <ATen/ops/col2im_native.h>
484
+ #include <ATen/ops/col_indices_native.h>
485
+ #include <ATen/ops/col_indices_copy_native.h>
486
+ #include <ATen/ops/column_stack_native.h>
487
+ #include <ATen/ops/combinations_native.h>
488
+ #include <ATen/ops/complex_native.h>
489
+ #include <ATen/ops/concat_native.h>
490
+ #include <ATen/ops/concatenate_native.h>
491
+ #include <ATen/ops/conj_native.h>
492
+ #include <ATen/ops/conj_physical_native.h>
493
+ #include <ATen/ops/constant_pad_nd_native.h>
494
+ #include <ATen/ops/contiguous_native.h>
495
+ #include <ATen/ops/conv1d_native.h>
496
+ #include <ATen/ops/conv2d_native.h>
497
+ #include <ATen/ops/conv3d_native.h>
498
+ #include <ATen/ops/conv_depthwise3d_native.h>
499
+ #include <ATen/ops/conv_tbc_native.h>
500
+ #include <ATen/ops/conv_tbc_backward_native.h>
501
+ #include <ATen/ops/conv_transpose1d_native.h>
502
+ #include <ATen/ops/conv_transpose2d_native.h>
503
+ #include <ATen/ops/conv_transpose3d_native.h>
504
+ #include <ATen/ops/convolution_native.h>
505
+ #include <ATen/ops/convolution_backward_native.h>
506
+ #include <ATen/ops/convolution_backward_overrideable_native.h>
507
+ #include <ATen/ops/convolution_overrideable_native.h>
508
+ #include <ATen/ops/copy_native.h>
509
+ #include <ATen/ops/copy_sparse_to_sparse_native.h>
510
+ #include <ATen/ops/copysign_native.h>
511
+ #include <ATen/ops/corrcoef_native.h>
512
+ #include <ATen/ops/cos_native.h>
513
+ #include <ATen/ops/cosh_native.h>
514
+ #include <ATen/ops/cosine_embedding_loss_native.h>
515
+ #include <ATen/ops/cosine_similarity_native.h>
516
+ #include <ATen/ops/count_nonzero_native.h>
517
+ #include <ATen/ops/cov_native.h>
518
+ #include <ATen/ops/cross_native.h>
519
+ #include <ATen/ops/cross_entropy_loss_native.h>
520
+ #include <ATen/ops/crow_indices_native.h>
521
+ #include <ATen/ops/crow_indices_copy_native.h>
522
+ #include <ATen/ops/ctc_loss_native.h>
523
+ #include <ATen/ops/cudnn_affine_grid_generator_native.h>
524
+ #include <ATen/ops/cudnn_affine_grid_generator_backward_native.h>
525
+ #include <ATen/ops/cudnn_batch_norm_native.h>
526
+ #include <ATen/ops/cudnn_batch_norm_backward_native.h>
527
+ #include <ATen/ops/cudnn_convolution_native.h>
528
+ #include <ATen/ops/cudnn_convolution_add_relu_native.h>
529
+ #include <ATen/ops/cudnn_convolution_relu_native.h>
530
+ #include <ATen/ops/cudnn_convolution_transpose_native.h>
531
+ #include <ATen/ops/cudnn_grid_sampler_native.h>
532
+ #include <ATen/ops/cudnn_grid_sampler_backward_native.h>
533
+ #include <ATen/ops/cudnn_is_acceptable_native.h>
534
+ #include <ATen/ops/cummax_native.h>
535
+ #include <ATen/ops/cummaxmin_backward_native.h>
536
+ #include <ATen/ops/cummin_native.h>
537
+ #include <ATen/ops/cumprod_native.h>
538
+ #include <ATen/ops/cumprod_backward_native.h>
539
+ #include <ATen/ops/cumsum_native.h>
540
+ #include <ATen/ops/cumulative_trapezoid_native.h>
541
+ #include <ATen/ops/data_native.h>
542
+ #include <ATen/ops/deg2rad_native.h>
543
+ #include <ATen/ops/dense_dim_native.h>
544
+ #include <ATen/ops/dequantize_native.h>
545
+ #include <ATen/ops/det_native.h>
546
+ #include <ATen/ops/detach_native.h>
547
+ #include <ATen/ops/detach_copy_native.h>
548
+ #include <ATen/ops/diag_native.h>
549
+ #include <ATen/ops/diag_embed_native.h>
550
+ #include <ATen/ops/diagflat_native.h>
551
+ #include <ATen/ops/diagonal_native.h>
552
+ #include <ATen/ops/diagonal_backward_native.h>
553
+ #include <ATen/ops/diagonal_copy_native.h>
554
+ #include <ATen/ops/diagonal_scatter_native.h>
555
+ #include <ATen/ops/diff_native.h>
556
+ #include <ATen/ops/digamma_native.h>
557
+ #include <ATen/ops/dist_native.h>
558
+ #include <ATen/ops/div_native.h>
559
+ #include <ATen/ops/divide_native.h>
560
+ #include <ATen/ops/dot_native.h>
561
+ #include <ATen/ops/dropout_native.h>
562
+ #include <ATen/ops/dsplit_native.h>
563
+ #include <ATen/ops/dstack_native.h>
564
+ #include <ATen/ops/einsum_native.h>
565
+ #include <ATen/ops/elu_native.h>
566
+ #include <ATen/ops/elu_backward_native.h>
567
+ #include <ATen/ops/embedding_native.h>
568
+ #include <ATen/ops/embedding_backward_native.h>
569
+ #include <ATen/ops/embedding_bag_native.h>
570
+ #include <ATen/ops/embedding_dense_backward_native.h>
571
+ #include <ATen/ops/embedding_renorm_native.h>
572
+ #include <ATen/ops/embedding_sparse_backward_native.h>
573
+ #include <ATen/ops/empty_native.h>
574
+ #include <ATen/ops/empty_like_native.h>
575
+ #include <ATen/ops/empty_permuted_native.h>
576
+ #include <ATen/ops/empty_quantized_native.h>
577
+ #include <ATen/ops/empty_strided_native.h>
578
+ #include <ATen/ops/eq_native.h>
579
+ #include <ATen/ops/equal_native.h>
580
+ #include <ATen/ops/erf_native.h>
581
+ #include <ATen/ops/erfc_native.h>
582
+ #include <ATen/ops/erfinv_native.h>
583
+ #include <ATen/ops/exp_native.h>
584
+ #include <ATen/ops/exp2_native.h>
585
+ #include <ATen/ops/expand_native.h>
586
+ #include <ATen/ops/expand_as_native.h>
587
+ #include <ATen/ops/expand_copy_native.h>
588
+ #include <ATen/ops/expm1_native.h>
589
+ #include <ATen/ops/exponential_native.h>
590
+ #include <ATen/ops/eye_native.h>
591
+ #include <ATen/ops/fake_quantize_per_channel_affine_native.h>
592
+ #include <ATen/ops/fake_quantize_per_channel_affine_cachemask_native.h>
593
+ #include <ATen/ops/fake_quantize_per_channel_affine_cachemask_backward_native.h>
594
+ #include <ATen/ops/fake_quantize_per_tensor_affine_native.h>
595
+ #include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_native.h>
596
+ #include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_native.h>
597
+ #include <ATen/ops/fbgemm_linear_fp16_weight_native.h>
598
+ #include <ATen/ops/fbgemm_linear_fp16_weight_fp32_activation_native.h>
599
+ #include <ATen/ops/fbgemm_linear_int8_weight_native.h>
600
+ #include <ATen/ops/fbgemm_linear_int8_weight_fp32_activation_native.h>
601
+ #include <ATen/ops/fbgemm_linear_quantize_weight_native.h>
602
+ #include <ATen/ops/fbgemm_pack_gemm_matrix_fp16_native.h>
603
+ #include <ATen/ops/fbgemm_pack_quantized_matrix_native.h>
604
+ #include <ATen/ops/feature_alpha_dropout_native.h>
605
+ #include <ATen/ops/feature_dropout_native.h>
606
+ #include <ATen/ops/fft_fft_native.h>
607
+ #include <ATen/ops/fft_fft2_native.h>
608
+ #include <ATen/ops/fft_fftfreq_native.h>
609
+ #include <ATen/ops/fft_fftn_native.h>
610
+ #include <ATen/ops/fft_fftshift_native.h>
611
+ #include <ATen/ops/fft_hfft_native.h>
612
+ #include <ATen/ops/fft_hfft2_native.h>
613
+ #include <ATen/ops/fft_hfftn_native.h>
614
+ #include <ATen/ops/fft_ifft_native.h>
615
+ #include <ATen/ops/fft_ifft2_native.h>
616
+ #include <ATen/ops/fft_ifftn_native.h>
617
+ #include <ATen/ops/fft_ifftshift_native.h>
618
+ #include <ATen/ops/fft_ihfft_native.h>
619
+ #include <ATen/ops/fft_ihfft2_native.h>
620
+ #include <ATen/ops/fft_ihfftn_native.h>
621
+ #include <ATen/ops/fft_irfft_native.h>
622
+ #include <ATen/ops/fft_irfft2_native.h>
623
+ #include <ATen/ops/fft_irfftn_native.h>
624
+ #include <ATen/ops/fft_rfft_native.h>
625
+ #include <ATen/ops/fft_rfft2_native.h>
626
+ #include <ATen/ops/fft_rfftfreq_native.h>
627
+ #include <ATen/ops/fft_rfftn_native.h>
628
+ #include <ATen/ops/fill_native.h>
629
+ #include <ATen/ops/fill_diagonal_native.h>
630
+ #include <ATen/ops/fix_native.h>
631
+ #include <ATen/ops/flatten_native.h>
632
+ #include <ATen/ops/flatten_dense_tensors_native.h>
633
+ #include <ATen/ops/flip_native.h>
634
+ #include <ATen/ops/fliplr_native.h>
635
+ #include <ATen/ops/flipud_native.h>
636
+ #include <ATen/ops/float_power_native.h>
637
+ #include <ATen/ops/floor_native.h>
638
+ #include <ATen/ops/floor_divide_native.h>
639
+ #include <ATen/ops/fmax_native.h>
640
+ #include <ATen/ops/fmin_native.h>
641
+ #include <ATen/ops/fmod_native.h>
642
+ #include <ATen/ops/frac_native.h>
643
+ #include <ATen/ops/fractional_max_pool2d_native.h>
644
+ #include <ATen/ops/fractional_max_pool2d_backward_native.h>
645
+ #include <ATen/ops/fractional_max_pool3d_native.h>
646
+ #include <ATen/ops/fractional_max_pool3d_backward_native.h>
647
+ #include <ATen/ops/frexp_native.h>
648
+ #include <ATen/ops/frobenius_norm_native.h>
649
+ #include <ATen/ops/from_file_native.h>
650
+ #include <ATen/ops/full_native.h>
651
+ #include <ATen/ops/full_like_native.h>
652
+ #include <ATen/ops/fused_moving_avg_obs_fake_quant_native.h>
653
+ #include <ATen/ops/gather_native.h>
654
+ #include <ATen/ops/gather_backward_native.h>
655
+ #include <ATen/ops/gcd_native.h>
656
+ #include <ATen/ops/ge_native.h>
657
+ #include <ATen/ops/gelu_native.h>
658
+ #include <ATen/ops/gelu_backward_native.h>
659
+ #include <ATen/ops/geometric_native.h>
660
+ #include <ATen/ops/geqrf_native.h>
661
+ #include <ATen/ops/ger_native.h>
662
+ #include <ATen/ops/glu_native.h>
663
+ #include <ATen/ops/glu_backward_native.h>
664
+ #include <ATen/ops/glu_backward_jvp_native.h>
665
+ #include <ATen/ops/glu_jvp_native.h>
666
+ #include <ATen/ops/gradient_native.h>
667
+ #include <ATen/ops/greater_native.h>
668
+ #include <ATen/ops/greater_equal_native.h>
669
+ #include <ATen/ops/grid_sampler_native.h>
670
+ #include <ATen/ops/grid_sampler_2d_native.h>
671
+ #include <ATen/ops/grid_sampler_2d_backward_native.h>
672
+ #include <ATen/ops/grid_sampler_3d_native.h>
673
+ #include <ATen/ops/grid_sampler_3d_backward_native.h>
674
+ #include <ATen/ops/group_norm_native.h>
675
+ #include <ATen/ops/gru_native.h>
676
+ #include <ATen/ops/gru_cell_native.h>
677
+ #include <ATen/ops/gt_native.h>
678
+ #include <ATen/ops/hamming_window_native.h>
679
+ #include <ATen/ops/hann_window_native.h>
680
+ #include <ATen/ops/hardshrink_native.h>
681
+ #include <ATen/ops/hardshrink_backward_native.h>
682
+ #include <ATen/ops/hardsigmoid_native.h>
683
+ #include <ATen/ops/hardsigmoid_backward_native.h>
684
+ #include <ATen/ops/hardswish_native.h>
685
+ #include <ATen/ops/hardswish_backward_native.h>
686
+ #include <ATen/ops/hardtanh_native.h>
687
+ #include <ATen/ops/hardtanh_backward_native.h>
688
+ #include <ATen/ops/heaviside_native.h>
689
+ #include <ATen/ops/hinge_embedding_loss_native.h>
690
+ #include <ATen/ops/histc_native.h>
691
+ #include <ATen/ops/histogram_native.h>
692
+ #include <ATen/ops/histogramdd_native.h>
693
+ #include <ATen/ops/hsplit_native.h>
694
+ #include <ATen/ops/hspmm_native.h>
695
+ #include <ATen/ops/hstack_native.h>
696
+ #include <ATen/ops/huber_loss_native.h>
697
+ #include <ATen/ops/huber_loss_backward_native.h>
698
+ #include <ATen/ops/hypot_native.h>
699
+ #include <ATen/ops/i0_native.h>
700
+ #include <ATen/ops/igamma_native.h>
701
+ #include <ATen/ops/igammac_native.h>
702
+ #include <ATen/ops/im2col_native.h>
703
+ #include <ATen/ops/imag_native.h>
704
+ #include <ATen/ops/index_native.h>
705
+ #include <ATen/ops/index_add_native.h>
706
+ #include <ATen/ops/index_copy_native.h>
707
+ #include <ATen/ops/index_fill_native.h>
708
+ #include <ATen/ops/index_put_native.h>
709
+ #include <ATen/ops/index_reduce_native.h>
710
+ #include <ATen/ops/index_select_native.h>
711
+ #include <ATen/ops/index_select_backward_native.h>
712
+ #include <ATen/ops/indices_native.h>
713
+ #include <ATen/ops/indices_copy_native.h>
714
+ #include <ATen/ops/infinitely_differentiable_gelu_backward_native.h>
715
+ #include <ATen/ops/inner_native.h>
716
+ #include <ATen/ops/instance_norm_native.h>
717
+ #include <ATen/ops/int_repr_native.h>
718
+ #include <ATen/ops/inverse_native.h>
719
+ #include <ATen/ops/is_coalesced_native.h>
720
+ #include <ATen/ops/is_complex_native.h>
721
+ #include <ATen/ops/is_conj_native.h>
722
+ #include <ATen/ops/is_distributed_native.h>
723
+ #include <ATen/ops/is_floating_point_native.h>
724
+ #include <ATen/ops/is_inference_native.h>
725
+ #include <ATen/ops/is_leaf_native.h>
726
+ #include <ATen/ops/is_neg_native.h>
727
+ #include <ATen/ops/is_nonzero_native.h>
728
+ #include <ATen/ops/is_pinned_native.h>
729
+ #include <ATen/ops/is_same_size_native.h>
730
+ #include <ATen/ops/is_set_to_native.h>
731
+ #include <ATen/ops/is_signed_native.h>
732
+ #include <ATen/ops/is_vulkan_available_native.h>
733
+ #include <ATen/ops/isclose_native.h>
734
+ #include <ATen/ops/isfinite_native.h>
735
+ #include <ATen/ops/isin_native.h>
736
+ #include <ATen/ops/isinf_native.h>
737
+ #include <ATen/ops/isnan_native.h>
738
+ #include <ATen/ops/isneginf_native.h>
739
+ #include <ATen/ops/isposinf_native.h>
740
+ #include <ATen/ops/isreal_native.h>
741
+ #include <ATen/ops/istft_native.h>
742
+ #include <ATen/ops/item_native.h>
743
+ #include <ATen/ops/kaiser_window_native.h>
744
+ #include <ATen/ops/kl_div_native.h>
745
+ #include <ATen/ops/kron_native.h>
746
+ #include <ATen/ops/kthvalue_native.h>
747
+ #include <ATen/ops/l1_loss_native.h>
748
+ #include <ATen/ops/layer_norm_native.h>
749
+ #include <ATen/ops/lcm_native.h>
750
+ #include <ATen/ops/ldexp_native.h>
751
+ #include <ATen/ops/le_native.h>
752
+ #include <ATen/ops/leaky_relu_native.h>
753
+ #include <ATen/ops/leaky_relu_backward_native.h>
754
+ #include <ATen/ops/lerp_native.h>
755
+ #include <ATen/ops/less_native.h>
756
+ #include <ATen/ops/less_equal_native.h>
757
+ #include <ATen/ops/lgamma_native.h>
758
+ #include <ATen/ops/lift_native.h>
759
+ #include <ATen/ops/lift_fresh_native.h>
760
+ #include <ATen/ops/lift_fresh_copy_native.h>
761
+ #include <ATen/ops/linalg_cholesky_native.h>
762
+ #include <ATen/ops/linalg_cholesky_ex_native.h>
763
+ #include <ATen/ops/linalg_cond_native.h>
764
+ #include <ATen/ops/linalg_cross_native.h>
765
+ #include <ATen/ops/linalg_det_native.h>
766
+ #include <ATen/ops/linalg_diagonal_native.h>
767
+ #include <ATen/ops/linalg_eig_native.h>
768
+ #include <ATen/ops/linalg_eigh_native.h>
769
+ #include <ATen/ops/linalg_eigvals_native.h>
770
+ #include <ATen/ops/linalg_eigvalsh_native.h>
771
+ #include <ATen/ops/linalg_householder_product_native.h>
772
+ #include <ATen/ops/linalg_inv_native.h>
773
+ #include <ATen/ops/linalg_inv_ex_native.h>
774
+ #include <ATen/ops/linalg_ldl_factor_native.h>
775
+ #include <ATen/ops/linalg_ldl_factor_ex_native.h>
776
+ #include <ATen/ops/linalg_ldl_solve_native.h>
777
+ #include <ATen/ops/linalg_lstsq_native.h>
778
+ #include <ATen/ops/linalg_lu_native.h>
779
+ #include <ATen/ops/linalg_lu_factor_native.h>
780
+ #include <ATen/ops/linalg_lu_factor_ex_native.h>
781
+ #include <ATen/ops/linalg_lu_solve_native.h>
782
+ #include <ATen/ops/linalg_matmul_native.h>
783
+ #include <ATen/ops/linalg_matrix_exp_native.h>
784
+ #include <ATen/ops/linalg_matrix_norm_native.h>
785
+ #include <ATen/ops/linalg_matrix_power_native.h>
786
+ #include <ATen/ops/linalg_matrix_rank_native.h>
787
+ #include <ATen/ops/linalg_multi_dot_native.h>
788
+ #include <ATen/ops/linalg_norm_native.h>
789
+ #include <ATen/ops/linalg_pinv_native.h>
790
+ #include <ATen/ops/linalg_qr_native.h>
791
+ #include <ATen/ops/linalg_slogdet_native.h>
792
+ #include <ATen/ops/linalg_solve_native.h>
793
+ #include <ATen/ops/linalg_solve_ex_native.h>
794
+ #include <ATen/ops/linalg_solve_triangular_native.h>
795
+ #include <ATen/ops/linalg_svd_native.h>
796
+ #include <ATen/ops/linalg_svdvals_native.h>
797
+ #include <ATen/ops/linalg_tensorinv_native.h>
798
+ #include <ATen/ops/linalg_tensorsolve_native.h>
799
+ #include <ATen/ops/linalg_vander_native.h>
800
+ #include <ATen/ops/linalg_vecdot_native.h>
801
+ #include <ATen/ops/linalg_vector_norm_native.h>
802
+ #include <ATen/ops/linear_native.h>
803
+ #include <ATen/ops/linear_backward_native.h>
804
+ #include <ATen/ops/linspace_native.h>
805
+ #include <ATen/ops/log_native.h>
806
+ #include <ATen/ops/log10_native.h>
807
+ #include <ATen/ops/log1p_native.h>
808
+ #include <ATen/ops/log2_native.h>
809
+ #include <ATen/ops/log_normal_native.h>
810
+ #include <ATen/ops/log_sigmoid_native.h>
811
+ #include <ATen/ops/log_sigmoid_backward_native.h>
812
+ #include <ATen/ops/log_sigmoid_forward_native.h>
813
+ #include <ATen/ops/log_softmax_native.h>
814
+ #include <ATen/ops/logaddexp_native.h>
815
+ #include <ATen/ops/logaddexp2_native.h>
816
+ #include <ATen/ops/logcumsumexp_native.h>
817
+ #include <ATen/ops/logdet_native.h>
818
+ #include <ATen/ops/logical_and_native.h>
819
+ #include <ATen/ops/logical_not_native.h>
820
+ #include <ATen/ops/logical_or_native.h>
821
+ #include <ATen/ops/logical_xor_native.h>
822
+ #include <ATen/ops/logit_native.h>
823
+ #include <ATen/ops/logit_backward_native.h>
824
+ #include <ATen/ops/logspace_native.h>
825
+ #include <ATen/ops/logsumexp_native.h>
826
+ #include <ATen/ops/lshift_native.h>
827
+ #include <ATen/ops/lstm_native.h>
828
+ #include <ATen/ops/lstm_cell_native.h>
829
+ #include <ATen/ops/lstm_mps_backward_native.h>
830
+ #include <ATen/ops/lt_native.h>
831
+ #include <ATen/ops/lu_solve_native.h>
832
+ #include <ATen/ops/lu_unpack_native.h>
833
+ #include <ATen/ops/mH_native.h>
834
+ #include <ATen/ops/mT_native.h>
835
+ #include <ATen/ops/margin_ranking_loss_native.h>
836
+ #include <ATen/ops/masked_fill_native.h>
837
+ #include <ATen/ops/masked_scatter_native.h>
838
+ #include <ATen/ops/masked_scatter_backward_native.h>
839
+ #include <ATen/ops/masked_select_native.h>
840
+ #include <ATen/ops/masked_select_backward_native.h>
841
+ #include <ATen/ops/matmul_native.h>
842
+ #include <ATen/ops/matmul_backward_native.h>
843
+ #include <ATen/ops/matrix_H_native.h>
844
+ #include <ATen/ops/matrix_exp_native.h>
845
+ #include <ATen/ops/matrix_exp_backward_native.h>
846
+ #include <ATen/ops/matrix_power_native.h>
847
+ #include <ATen/ops/max_native.h>
848
+ #include <ATen/ops/max_pool1d_native.h>
849
+ #include <ATen/ops/max_pool1d_with_indices_native.h>
850
+ #include <ATen/ops/max_pool2d_native.h>
851
+ #include <ATen/ops/max_pool2d_backward_native.h>
852
+ #include <ATen/ops/max_pool2d_with_indices_native.h>
853
+ #include <ATen/ops/max_pool2d_with_indices_backward_native.h>
854
+ #include <ATen/ops/max_pool3d_native.h>
855
+ #include <ATen/ops/max_pool3d_with_indices_native.h>
856
+ #include <ATen/ops/max_pool3d_with_indices_backward_native.h>
857
+ #include <ATen/ops/max_unpool2d_native.h>
858
+ #include <ATen/ops/max_unpool3d_native.h>
859
+ #include <ATen/ops/maximum_native.h>
860
+ #include <ATen/ops/mean_native.h>
861
+ #include <ATen/ops/median_native.h>
862
+ #include <ATen/ops/meshgrid_native.h>
863
+ #include <ATen/ops/min_native.h>
864
+ #include <ATen/ops/minimum_native.h>
865
+ #include <ATen/ops/miopen_batch_norm_native.h>
866
+ #include <ATen/ops/miopen_batch_norm_backward_native.h>
867
+ #include <ATen/ops/miopen_convolution_native.h>
868
+ #include <ATen/ops/miopen_convolution_add_relu_native.h>
869
+ #include <ATen/ops/miopen_convolution_relu_native.h>
870
+ #include <ATen/ops/miopen_convolution_transpose_native.h>
871
+ #include <ATen/ops/miopen_depthwise_convolution_native.h>
872
+ #include <ATen/ops/miopen_rnn_native.h>
873
+ #include <ATen/ops/miopen_rnn_backward_native.h>
874
+ #include <ATen/ops/mish_native.h>
875
+ #include <ATen/ops/mish_backward_native.h>
876
+ #include <ATen/ops/mkldnn_adaptive_avg_pool2d_native.h>
877
+ #include <ATen/ops/mkldnn_adaptive_avg_pool2d_backward_native.h>
878
+ #include <ATen/ops/mkldnn_convolution_native.h>
879
+ #include <ATen/ops/mkldnn_linear_native.h>
880
+ #include <ATen/ops/mkldnn_linear_backward_native.h>
881
+ #include <ATen/ops/mkldnn_linear_backward_input_native.h>
882
+ #include <ATen/ops/mkldnn_linear_backward_weights_native.h>
883
+ #include <ATen/ops/mkldnn_max_pool2d_native.h>
884
+ #include <ATen/ops/mkldnn_max_pool2d_backward_native.h>
885
+ #include <ATen/ops/mkldnn_max_pool3d_native.h>
886
+ #include <ATen/ops/mkldnn_max_pool3d_backward_native.h>
887
+ #include <ATen/ops/mkldnn_reorder_conv2d_weight_native.h>
888
+ #include <ATen/ops/mkldnn_reorder_conv3d_weight_native.h>
889
+ #include <ATen/ops/mkldnn_rnn_layer_native.h>
890
+ #include <ATen/ops/mkldnn_rnn_layer_backward_native.h>
891
+ #include <ATen/ops/mm_native.h>
892
+ #include <ATen/ops/mode_native.h>
893
+ #include <ATen/ops/moveaxis_native.h>
894
+ #include <ATen/ops/movedim_native.h>
895
+ #include <ATen/ops/mps_convolution_backward_native.h>
896
+ #include <ATen/ops/mps_convolution_transpose_backward_native.h>
897
+ #include <ATen/ops/mse_loss_native.h>
898
+ #include <ATen/ops/mse_loss_backward_native.h>
899
+ #include <ATen/ops/msort_native.h>
900
+ #include <ATen/ops/mul_native.h>
901
+ #include <ATen/ops/multi_margin_loss_native.h>
902
+ #include <ATen/ops/multi_margin_loss_backward_native.h>
903
+ #include <ATen/ops/multilabel_margin_loss_native.h>
904
+ #include <ATen/ops/multilabel_margin_loss_backward_native.h>
905
+ #include <ATen/ops/multilabel_margin_loss_forward_native.h>
906
+ #include <ATen/ops/multinomial_native.h>
907
+ #include <ATen/ops/multiply_native.h>
908
+ #include <ATen/ops/mv_native.h>
909
+ #include <ATen/ops/mvlgamma_native.h>
910
+ #include <ATen/ops/nan_to_num_native.h>
911
+ #include <ATen/ops/nanmean_native.h>
912
+ #include <ATen/ops/nanmedian_native.h>
913
+ #include <ATen/ops/nanquantile_native.h>
914
+ #include <ATen/ops/nansum_native.h>
915
+ #include <ATen/ops/narrow_native.h>
916
+ #include <ATen/ops/narrow_copy_native.h>
917
+ #include <ATen/ops/native_batch_norm_native.h>
918
+ #include <ATen/ops/native_batch_norm_backward_native.h>
919
+ #include <ATen/ops/native_channel_shuffle_native.h>
920
+ #include <ATen/ops/native_dropout_native.h>
921
+ #include <ATen/ops/native_dropout_backward_native.h>
922
+ #include <ATen/ops/native_group_norm_native.h>
923
+ #include <ATen/ops/native_group_norm_backward_native.h>
924
+ #include <ATen/ops/native_layer_norm_native.h>
925
+ #include <ATen/ops/native_layer_norm_backward_native.h>
926
+ #include <ATen/ops/native_norm_native.h>
927
+ #include <ATen/ops/ne_native.h>
928
+ #include <ATen/ops/neg_native.h>
929
+ #include <ATen/ops/negative_native.h>
930
+ #include <ATen/ops/nested_to_padded_tensor_native.h>
931
+ #include <ATen/ops/new_empty_native.h>
932
+ #include <ATen/ops/new_empty_strided_native.h>
933
+ #include <ATen/ops/new_full_native.h>
934
+ #include <ATen/ops/new_ones_native.h>
935
+ #include <ATen/ops/new_zeros_native.h>
936
+ #include <ATen/ops/nextafter_native.h>
937
+ #include <ATen/ops/nll_loss_native.h>
938
+ #include <ATen/ops/nll_loss2d_native.h>
939
+ #include <ATen/ops/nll_loss2d_backward_native.h>
940
+ #include <ATen/ops/nll_loss2d_forward_native.h>
941
+ #include <ATen/ops/nll_loss_backward_native.h>
942
+ #include <ATen/ops/nll_loss_forward_native.h>
943
+ #include <ATen/ops/nll_loss_nd_native.h>
944
+ #include <ATen/ops/nonzero_native.h>
945
+ #include <ATen/ops/nonzero_numpy_native.h>
946
+ #include <ATen/ops/nonzero_static_native.h>
947
+ #include <ATen/ops/norm_native.h>
948
+ #include <ATen/ops/norm_except_dim_native.h>
949
+ #include <ATen/ops/normal_native.h>
950
+ #include <ATen/ops/not_equal_native.h>
951
+ #include <ATen/ops/nuclear_norm_native.h>
952
+ #include <ATen/ops/numpy_T_native.h>
953
+ #include <ATen/ops/one_hot_native.h>
954
+ #include <ATen/ops/ones_native.h>
955
+ #include <ATen/ops/ones_like_native.h>
956
+ #include <ATen/ops/or_native.h>
957
+ #include <ATen/ops/orgqr_native.h>
958
+ #include <ATen/ops/ormqr_native.h>
959
+ #include <ATen/ops/outer_native.h>
960
+ #include <ATen/ops/output_nr_native.h>
961
+ #include <ATen/ops/pad_native.h>
962
+ #include <ATen/ops/pad_sequence_native.h>
963
+ #include <ATen/ops/pairwise_distance_native.h>
964
+ #include <ATen/ops/pdist_native.h>
965
+ #include <ATen/ops/permute_native.h>
966
+ #include <ATen/ops/permute_copy_native.h>
967
+ #include <ATen/ops/pin_memory_native.h>
968
+ #include <ATen/ops/pinverse_native.h>
969
+ #include <ATen/ops/pixel_shuffle_native.h>
970
+ #include <ATen/ops/pixel_unshuffle_native.h>
971
+ #include <ATen/ops/poisson_native.h>
972
+ #include <ATen/ops/poisson_nll_loss_native.h>
973
+ #include <ATen/ops/polar_native.h>
974
+ #include <ATen/ops/polygamma_native.h>
975
+ #include <ATen/ops/positive_native.h>
976
+ #include <ATen/ops/pow_native.h>
977
+ #include <ATen/ops/prelu_native.h>
978
+ #include <ATen/ops/prod_native.h>
979
+ #include <ATen/ops/promote_types_native.h>
980
+ #include <ATen/ops/put_native.h>
981
+ #include <ATen/ops/q_per_channel_axis_native.h>
982
+ #include <ATen/ops/q_per_channel_scales_native.h>
983
+ #include <ATen/ops/q_per_channel_zero_points_native.h>
984
+ #include <ATen/ops/q_scale_native.h>
985
+ #include <ATen/ops/q_zero_point_native.h>
986
+ #include <ATen/ops/qr_native.h>
987
+ #include <ATen/ops/qscheme_native.h>
988
+ #include <ATen/ops/quantile_native.h>
989
+ #include <ATen/ops/quantize_per_channel_native.h>
990
+ #include <ATen/ops/quantize_per_tensor_native.h>
991
+ #include <ATen/ops/quantize_per_tensor_dynamic_native.h>
992
+ #include <ATen/ops/quantized_batch_norm_native.h>
993
+ #include <ATen/ops/quantized_gru_cell_native.h>
994
+ #include <ATen/ops/quantized_lstm_cell_native.h>
995
+ #include <ATen/ops/quantized_max_pool1d_native.h>
996
+ #include <ATen/ops/quantized_max_pool2d_native.h>
997
+ #include <ATen/ops/quantized_max_pool3d_native.h>
998
+ #include <ATen/ops/quantized_rnn_relu_cell_native.h>
999
+ #include <ATen/ops/quantized_rnn_tanh_cell_native.h>
1000
+ #include <ATen/ops/rad2deg_native.h>
1001
+ #include <ATen/ops/rand_native.h>
1002
+ #include <ATen/ops/rand_like_native.h>
1003
+ #include <ATen/ops/randint_native.h>
1004
+ #include <ATen/ops/randint_like_native.h>
1005
+ #include <ATen/ops/randn_native.h>
1006
+ #include <ATen/ops/randn_like_native.h>
1007
+ #include <ATen/ops/random_native.h>
1008
+ #include <ATen/ops/randperm_native.h>
1009
+ #include <ATen/ops/range_native.h>
1010
+ #include <ATen/ops/ravel_native.h>
1011
+ #include <ATen/ops/real_native.h>
1012
+ #include <ATen/ops/reciprocal_native.h>
1013
+ #include <ATen/ops/record_stream_native.h>
1014
+ #include <ATen/ops/refine_names_native.h>
1015
+ #include <ATen/ops/reflection_pad1d_native.h>
1016
+ #include <ATen/ops/reflection_pad1d_backward_native.h>
1017
+ #include <ATen/ops/reflection_pad2d_native.h>
1018
+ #include <ATen/ops/reflection_pad2d_backward_native.h>
1019
+ #include <ATen/ops/reflection_pad3d_native.h>
1020
+ #include <ATen/ops/reflection_pad3d_backward_native.h>
1021
+ #include <ATen/ops/relu_native.h>
1022
+ #include <ATen/ops/relu6_native.h>
1023
+ #include <ATen/ops/remainder_native.h>
1024
+ #include <ATen/ops/rename_native.h>
1025
+ #include <ATen/ops/renorm_native.h>
1026
+ #include <ATen/ops/repeat_native.h>
1027
+ #include <ATen/ops/repeat_interleave_native.h>
1028
+ #include <ATen/ops/replication_pad1d_native.h>
1029
+ #include <ATen/ops/replication_pad1d_backward_native.h>
1030
+ #include <ATen/ops/replication_pad2d_native.h>
1031
+ #include <ATen/ops/replication_pad2d_backward_native.h>
1032
+ #include <ATen/ops/replication_pad3d_native.h>
1033
+ #include <ATen/ops/replication_pad3d_backward_native.h>
1034
+ #include <ATen/ops/requires_grad_native.h>
1035
+ #include <ATen/ops/reshape_native.h>
1036
+ #include <ATen/ops/reshape_as_native.h>
1037
+ #include <ATen/ops/resize_native.h>
1038
+ #include <ATen/ops/resize_as_native.h>
1039
+ #include <ATen/ops/resize_as_sparse_native.h>
1040
+ #include <ATen/ops/resolve_conj_native.h>
1041
+ #include <ATen/ops/resolve_neg_native.h>
1042
+ #include <ATen/ops/result_type_native.h>
1043
+ #include <ATen/ops/retain_grad_native.h>
1044
+ #include <ATen/ops/retains_grad_native.h>
1045
+ #include <ATen/ops/rnn_relu_native.h>
1046
+ #include <ATen/ops/rnn_relu_cell_native.h>
1047
+ #include <ATen/ops/rnn_tanh_native.h>
1048
+ #include <ATen/ops/rnn_tanh_cell_native.h>
1049
+ #include <ATen/ops/roll_native.h>
1050
+ #include <ATen/ops/rot90_native.h>
1051
+ #include <ATen/ops/round_native.h>
1052
+ #include <ATen/ops/row_indices_native.h>
1053
+ #include <ATen/ops/row_indices_copy_native.h>
1054
+ #include <ATen/ops/row_stack_native.h>
1055
+ #include <ATen/ops/rrelu_native.h>
1056
+ #include <ATen/ops/rrelu_with_noise_native.h>
1057
+ #include <ATen/ops/rrelu_with_noise_backward_native.h>
1058
+ #include <ATen/ops/rshift_native.h>
1059
+ #include <ATen/ops/rsqrt_native.h>
1060
+ #include <ATen/ops/rsub_native.h>
1061
+ #include <ATen/ops/scalar_tensor_native.h>
1062
+ #include <ATen/ops/scaled_dot_product_attention_native.h>
1063
+ #include <ATen/ops/scatter_native.h>
1064
+ #include <ATen/ops/scatter_add_native.h>
1065
+ #include <ATen/ops/scatter_reduce_native.h>
1066
+ #include <ATen/ops/searchsorted_native.h>
1067
+ #include <ATen/ops/segment_reduce_native.h>
1068
+ #include <ATen/ops/select_native.h>
1069
+ #include <ATen/ops/select_backward_native.h>
1070
+ #include <ATen/ops/select_copy_native.h>
1071
+ #include <ATen/ops/select_scatter_native.h>
1072
+ #include <ATen/ops/selu_native.h>
1073
+ #include <ATen/ops/set_native.h>
1074
+ #include <ATen/ops/set_data_native.h>
1075
+ #include <ATen/ops/sgn_native.h>
1076
+ #include <ATen/ops/sigmoid_native.h>
1077
+ #include <ATen/ops/sigmoid_backward_native.h>
1078
+ #include <ATen/ops/sign_native.h>
1079
+ #include <ATen/ops/signbit_native.h>
1080
+ #include <ATen/ops/silu_native.h>
1081
+ #include <ATen/ops/silu_backward_native.h>
1082
+ #include <ATen/ops/sin_native.h>
1083
+ #include <ATen/ops/sinc_native.h>
1084
+ #include <ATen/ops/sinh_native.h>
1085
+ #include <ATen/ops/size_native.h>
1086
+ #include <ATen/ops/slice_native.h>
1087
+ #include <ATen/ops/slice_backward_native.h>
1088
+ #include <ATen/ops/slice_copy_native.h>
1089
+ #include <ATen/ops/slice_scatter_native.h>
1090
+ #include <ATen/ops/slogdet_native.h>
1091
+ #include <ATen/ops/slow_conv3d_native.h>
1092
+ #include <ATen/ops/slow_conv3d_forward_native.h>
1093
+ #include <ATen/ops/slow_conv_dilated2d_native.h>
1094
+ #include <ATen/ops/slow_conv_dilated3d_native.h>
1095
+ #include <ATen/ops/slow_conv_transpose2d_native.h>
1096
+ #include <ATen/ops/slow_conv_transpose3d_native.h>
1097
+ #include <ATen/ops/smm_native.h>
1098
+ #include <ATen/ops/smooth_l1_loss_native.h>
1099
+ #include <ATen/ops/smooth_l1_loss_backward_native.h>
1100
+ #include <ATen/ops/soft_margin_loss_native.h>
1101
+ #include <ATen/ops/soft_margin_loss_backward_native.h>
1102
+ #include <ATen/ops/softmax_native.h>
1103
+ #include <ATen/ops/softplus_native.h>
1104
+ #include <ATen/ops/softplus_backward_native.h>
1105
+ #include <ATen/ops/softshrink_native.h>
1106
+ #include <ATen/ops/softshrink_backward_native.h>
1107
+ #include <ATen/ops/sort_native.h>
1108
+ #include <ATen/ops/sparse_bsc_tensor_native.h>
1109
+ #include <ATen/ops/sparse_bsr_tensor_native.h>
1110
+ #include <ATen/ops/sparse_compressed_tensor_native.h>
1111
+ #include <ATen/ops/sparse_coo_tensor_native.h>
1112
+ #include <ATen/ops/sparse_csc_tensor_native.h>
1113
+ #include <ATen/ops/sparse_csr_tensor_native.h>
1114
+ #include <ATen/ops/sparse_dim_native.h>
1115
+ #include <ATen/ops/sparse_mask_native.h>
1116
+ #include <ATen/ops/sparse_resize_native.h>
1117
+ #include <ATen/ops/sparse_resize_and_clear_native.h>
1118
+ #include <ATen/ops/sparse_sampled_addmm_native.h>
1119
+ #include <ATen/ops/special_airy_ai_native.h>
1120
+ #include <ATen/ops/special_bessel_j0_native.h>
1121
+ #include <ATen/ops/special_bessel_j1_native.h>
1122
+ #include <ATen/ops/special_bessel_y0_native.h>
1123
+ #include <ATen/ops/special_bessel_y1_native.h>
1124
+ #include <ATen/ops/special_chebyshev_polynomial_t_native.h>
1125
+ #include <ATen/ops/special_chebyshev_polynomial_u_native.h>
1126
+ #include <ATen/ops/special_chebyshev_polynomial_v_native.h>
1127
+ #include <ATen/ops/special_chebyshev_polynomial_w_native.h>
1128
+ #include <ATen/ops/special_digamma_native.h>
1129
+ #include <ATen/ops/special_entr_native.h>
1130
+ #include <ATen/ops/special_erf_native.h>
1131
+ #include <ATen/ops/special_erfc_native.h>
1132
+ #include <ATen/ops/special_erfcx_native.h>
1133
+ #include <ATen/ops/special_erfinv_native.h>
1134
+ #include <ATen/ops/special_exp2_native.h>
1135
+ #include <ATen/ops/special_expit_native.h>
1136
+ #include <ATen/ops/special_expm1_native.h>
1137
+ #include <ATen/ops/special_gammainc_native.h>
1138
+ #include <ATen/ops/special_gammaincc_native.h>
1139
+ #include <ATen/ops/special_gammaln_native.h>
1140
+ #include <ATen/ops/special_hermite_polynomial_h_native.h>
1141
+ #include <ATen/ops/special_hermite_polynomial_he_native.h>
1142
+ #include <ATen/ops/special_i0_native.h>
1143
+ #include <ATen/ops/special_i0e_native.h>
1144
+ #include <ATen/ops/special_i1_native.h>
1145
+ #include <ATen/ops/special_i1e_native.h>
1146
+ #include <ATen/ops/special_laguerre_polynomial_l_native.h>
1147
+ #include <ATen/ops/special_legendre_polynomial_p_native.h>
1148
+ #include <ATen/ops/special_log1p_native.h>
1149
+ #include <ATen/ops/special_log_ndtr_native.h>
1150
+ #include <ATen/ops/special_log_softmax_native.h>
1151
+ #include <ATen/ops/special_logit_native.h>
1152
+ #include <ATen/ops/special_logsumexp_native.h>
1153
+ #include <ATen/ops/special_modified_bessel_i0_native.h>
1154
+ #include <ATen/ops/special_modified_bessel_i1_native.h>
1155
+ #include <ATen/ops/special_modified_bessel_k0_native.h>
1156
+ #include <ATen/ops/special_modified_bessel_k1_native.h>
1157
+ #include <ATen/ops/special_multigammaln_native.h>
1158
+ #include <ATen/ops/special_ndtr_native.h>
1159
+ #include <ATen/ops/special_ndtri_native.h>
1160
+ #include <ATen/ops/special_polygamma_native.h>
1161
+ #include <ATen/ops/special_psi_native.h>
1162
+ #include <ATen/ops/special_round_native.h>
1163
+ #include <ATen/ops/special_scaled_modified_bessel_k0_native.h>
1164
+ #include <ATen/ops/special_scaled_modified_bessel_k1_native.h>
1165
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_t_native.h>
1166
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_u_native.h>
1167
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_v_native.h>
1168
+ #include <ATen/ops/special_shifted_chebyshev_polynomial_w_native.h>
1169
+ #include <ATen/ops/special_sinc_native.h>
1170
+ #include <ATen/ops/special_softmax_native.h>
1171
+ #include <ATen/ops/special_spherical_bessel_j0_native.h>
1172
+ #include <ATen/ops/special_xlog1py_native.h>
1173
+ #include <ATen/ops/special_xlogy_native.h>
1174
+ #include <ATen/ops/special_zeta_native.h>
1175
+ #include <ATen/ops/split_native.h>
1176
+ #include <ATen/ops/split_copy_native.h>
1177
+ #include <ATen/ops/split_with_sizes_native.h>
1178
+ #include <ATen/ops/split_with_sizes_copy_native.h>
1179
+ #include <ATen/ops/sqrt_native.h>
1180
+ #include <ATen/ops/square_native.h>
1181
+ #include <ATen/ops/squeeze_native.h>
1182
+ #include <ATen/ops/squeeze_copy_native.h>
1183
+ #include <ATen/ops/sspaddmm_native.h>
1184
+ #include <ATen/ops/stack_native.h>
1185
+ #include <ATen/ops/std_native.h>
1186
+ #include <ATen/ops/std_mean_native.h>
1187
+ #include <ATen/ops/stft_native.h>
1188
+ #include <ATen/ops/stride_native.h>
1189
+ #include <ATen/ops/sub_native.h>
1190
+ #include <ATen/ops/subtract_native.h>
1191
+ #include <ATen/ops/sum_native.h>
1192
+ #include <ATen/ops/sum_to_size_native.h>
1193
+ #include <ATen/ops/svd_native.h>
1194
+ #include <ATen/ops/swapaxes_native.h>
1195
+ #include <ATen/ops/swapdims_native.h>
1196
+ #include <ATen/ops/sym_constrain_range_native.h>
1197
+ #include <ATen/ops/sym_constrain_range_for_size_native.h>
1198
+ #include <ATen/ops/sym_numel_native.h>
1199
+ #include <ATen/ops/sym_size_native.h>
1200
+ #include <ATen/ops/sym_storage_offset_native.h>
1201
+ #include <ATen/ops/sym_stride_native.h>
1202
+ #include <ATen/ops/t_native.h>
1203
+ #include <ATen/ops/t_copy_native.h>
1204
+ #include <ATen/ops/take_native.h>
1205
+ #include <ATen/ops/take_along_dim_native.h>
1206
+ #include <ATen/ops/tan_native.h>
1207
+ #include <ATen/ops/tanh_native.h>
1208
+ #include <ATen/ops/tanh_backward_native.h>
1209
+ #include <ATen/ops/tensor_split_native.h>
1210
+ #include <ATen/ops/tensordot_native.h>
1211
+ #include <ATen/ops/thnn_conv2d_native.h>
1212
+ #include <ATen/ops/threshold_native.h>
1213
+ #include <ATen/ops/threshold_backward_native.h>
1214
+ #include <ATen/ops/tile_native.h>
1215
+ #include <ATen/ops/to_native.h>
1216
+ #include <ATen/ops/to_dense_native.h>
1217
+ #include <ATen/ops/to_dense_backward_native.h>
1218
+ #include <ATen/ops/to_mkldnn_native.h>
1219
+ #include <ATen/ops/to_mkldnn_backward_native.h>
1220
+ #include <ATen/ops/to_padded_tensor_native.h>
1221
+ #include <ATen/ops/to_sparse_native.h>
1222
+ #include <ATen/ops/to_sparse_bsc_native.h>
1223
+ #include <ATen/ops/to_sparse_bsr_native.h>
1224
+ #include <ATen/ops/to_sparse_csc_native.h>
1225
+ #include <ATen/ops/to_sparse_csr_native.h>
1226
+ #include <ATen/ops/topk_native.h>
1227
+ #include <ATen/ops/trace_native.h>
1228
+ #include <ATen/ops/trace_backward_native.h>
1229
+ #include <ATen/ops/transpose_native.h>
1230
+ #include <ATen/ops/transpose_copy_native.h>
1231
+ #include <ATen/ops/trapezoid_native.h>
1232
+ #include <ATen/ops/trapz_native.h>
1233
+ #include <ATen/ops/triangular_solve_native.h>
1234
+ #include <ATen/ops/tril_native.h>
1235
+ #include <ATen/ops/tril_indices_native.h>
1236
+ #include <ATen/ops/triplet_margin_loss_native.h>
1237
+ #include <ATen/ops/triu_native.h>
1238
+ #include <ATen/ops/triu_indices_native.h>
1239
+ #include <ATen/ops/true_divide_native.h>
1240
+ #include <ATen/ops/trunc_native.h>
1241
+ #include <ATen/ops/type_as_native.h>
1242
+ #include <ATen/ops/unbind_native.h>
1243
+ #include <ATen/ops/unbind_copy_native.h>
1244
+ #include <ATen/ops/unflatten_native.h>
1245
+ #include <ATen/ops/unflatten_dense_tensors_native.h>
1246
+ #include <ATen/ops/unfold_native.h>
1247
+ #include <ATen/ops/unfold_backward_native.h>
1248
+ #include <ATen/ops/unfold_copy_native.h>
1249
+ #include <ATen/ops/uniform_native.h>
1250
+ #include <ATen/ops/unique_consecutive_native.h>
1251
+ #include <ATen/ops/unique_dim_native.h>
1252
+ #include <ATen/ops/unique_dim_consecutive_native.h>
1253
+ #include <ATen/ops/unsafe_chunk_native.h>
1254
+ #include <ATen/ops/unsafe_split_native.h>
1255
+ #include <ATen/ops/unsafe_split_with_sizes_native.h>
1256
+ #include <ATen/ops/unsqueeze_native.h>
1257
+ #include <ATen/ops/unsqueeze_copy_native.h>
1258
+ #include <ATen/ops/upsample_bicubic2d_native.h>
1259
+ #include <ATen/ops/upsample_bicubic2d_backward_native.h>
1260
+ #include <ATen/ops/upsample_bilinear2d_native.h>
1261
+ #include <ATen/ops/upsample_bilinear2d_backward_native.h>
1262
+ #include <ATen/ops/upsample_linear1d_native.h>
1263
+ #include <ATen/ops/upsample_linear1d_backward_native.h>
1264
+ #include <ATen/ops/upsample_nearest1d_native.h>
1265
+ #include <ATen/ops/upsample_nearest1d_backward_native.h>
1266
+ #include <ATen/ops/upsample_nearest2d_native.h>
1267
+ #include <ATen/ops/upsample_nearest2d_backward_native.h>
1268
+ #include <ATen/ops/upsample_nearest3d_native.h>
1269
+ #include <ATen/ops/upsample_nearest3d_backward_native.h>
1270
+ #include <ATen/ops/upsample_trilinear3d_native.h>
1271
+ #include <ATen/ops/upsample_trilinear3d_backward_native.h>
1272
+ #include <ATen/ops/value_selecting_reduction_backward_native.h>
1273
+ #include <ATen/ops/values_native.h>
1274
+ #include <ATen/ops/values_copy_native.h>
1275
+ #include <ATen/ops/vander_native.h>
1276
+ #include <ATen/ops/var_native.h>
1277
+ #include <ATen/ops/var_mean_native.h>
1278
+ #include <ATen/ops/vdot_native.h>
1279
+ #include <ATen/ops/view_native.h>
1280
+ #include <ATen/ops/view_as_native.h>
1281
+ #include <ATen/ops/view_as_complex_native.h>
1282
+ #include <ATen/ops/view_as_complex_copy_native.h>
1283
+ #include <ATen/ops/view_as_real_native.h>
1284
+ #include <ATen/ops/view_as_real_copy_native.h>
1285
+ #include <ATen/ops/view_copy_native.h>
1286
+ #include <ATen/ops/vsplit_native.h>
1287
+ #include <ATen/ops/vstack_native.h>
1288
+ #include <ATen/ops/where_native.h>
1289
+ #include <ATen/ops/xlogy_native.h>
1290
+ #include <ATen/ops/xor_native.h>
1291
+ #include <ATen/ops/zero_native.h>
1292
+ #include <ATen/ops/zeros_native.h>
1293
+ #include <ATen/ops/zeros_like_native.h>
1294
+
1295
+
videollama2/lib/python3.10/site-packages/torch/include/ATen/OpMathType.h ADDED
@@ -0,0 +1,59 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/core/ScalarType.h>
4
+ #include <c10/util/BFloat16.h>
5
+ #include <c10/util/Exception.h>
6
+ #include <c10/util/Float8_e4m3fn.h>
7
+ #include <c10/util/Float8_e5m2.h>
8
+ #include <c10/util/Half.h>
9
+
10
+ namespace at {
11
+
12
+ // For FP16 or BFloat16 inputs, ops should perform internal math in FP32.
13
+ template <typename scalar_t>
14
+ struct OpMathType {
15
+ using type = scalar_t;
16
+ };
17
+ template <>
18
+ struct OpMathType<at::Half> {
19
+ using type = float;
20
+ };
21
+ template <>
22
+ struct OpMathType<at::BFloat16> {
23
+ using type = float;
24
+ };
25
+ template <>
26
+ struct OpMathType<at::Float8_e5m2> {
27
+ using type = float;
28
+ };
29
+ template <>
30
+ struct OpMathType<at::Float8_e4m3fn> {
31
+ using type = float;
32
+ };
33
+ template <>
34
+ struct OpMathType<c10::complex<Half>> {
35
+ using type = c10::complex<float>;
36
+ };
37
+
38
+ template <typename T>
39
+ using opmath_type = typename OpMathType<T>::type;
40
+
41
+ namespace {
42
+
43
+ inline c10::ScalarType toOpMathType(const c10::ScalarType type) {
44
+ switch (type) {
45
+ #define DEFINE_CASE(scalar_t, TypeNum) \
46
+ case ScalarType::TypeNum: \
47
+ return CppTypeToScalarType<at::opmath_type<scalar_t>>::value;
48
+
49
+ AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_CASE)
50
+ #undef DEFINE_CASE
51
+
52
+ default:
53
+ TORCH_INTERNAL_ASSERT(false, "Unrecognized ScalarType: ", type);
54
+ }
55
+ }
56
+
57
+ } // namespace
58
+
59
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/PTThreadPool.h ADDED
@@ -0,0 +1,17 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/Parallel.h>
4
+ #include <c10/core/thread_pool.h>
5
+
6
+ namespace at {
7
+
8
+ class TORCH_API PTThreadPool : public c10::ThreadPool {
9
+ public:
10
+ explicit PTThreadPool(int pool_size, int numa_node_id = -1)
11
+ : c10::ThreadPool(pool_size, numa_node_id, []() {
12
+ c10::setThreadName("PTThreadPool");
13
+ at::init_num_threads();
14
+ }) {}
15
+ };
16
+
17
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/ParallelFuture.h ADDED
@@ -0,0 +1,13 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/core/ivalue.h>
4
+ #include <c10/macros/Macros.h>
5
+ #include <functional>
6
+
7
+ namespace at {
8
+
9
+ // Launches intra-op parallel task, returns a future
10
+ TORCH_API c10::intrusive_ptr<c10::ivalue::Future> intraop_launch_future(
11
+ std::function<void()> func);
12
+
13
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/ParallelNative.h ADDED
@@ -0,0 +1,19 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <algorithm>
4
+ #include <cstddef>
5
+ #include <exception>
6
+
7
+ #include <c10/util/Exception.h>
8
+
9
+ #define INTRA_OP_PARALLEL
10
+
11
+ namespace at::internal {
12
+
13
+ TORCH_API void invoke_parallel(
14
+ const int64_t begin,
15
+ const int64_t end,
16
+ const int64_t grain_size,
17
+ const std::function<void(int64_t, int64_t)>& f);
18
+
19
+ } // namespace at::internal
videollama2/lib/python3.10/site-packages/torch/include/ATen/ParallelOpenMP.h ADDED
@@ -0,0 +1,58 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <algorithm>
4
+ #include <atomic>
5
+ #include <cstddef>
6
+ #include <exception>
7
+
8
+ #ifdef _OPENMP
9
+ #define INTRA_OP_PARALLEL
10
+
11
+ #include <omp.h>
12
+ #endif
13
+
14
+ namespace at {
15
+
16
+ #ifdef _OPENMP
17
+ namespace internal {
18
+ template <typename F>
19
+ inline void invoke_parallel(
20
+ int64_t begin,
21
+ int64_t end,
22
+ int64_t grain_size,
23
+ const F& f) {
24
+ std::atomic_flag err_flag = ATOMIC_FLAG_INIT;
25
+ std::exception_ptr eptr;
26
+
27
+ #pragma omp parallel
28
+ {
29
+ // choose number of tasks based on grain size and number of threads
30
+ // can't use num_threads clause due to bugs in GOMP's thread pool (See
31
+ // #32008)
32
+ int64_t num_threads = omp_get_num_threads();
33
+ if (grain_size > 0) {
34
+ num_threads = std::min(num_threads, divup((end - begin), grain_size));
35
+ }
36
+
37
+ int64_t tid = omp_get_thread_num();
38
+ int64_t chunk_size = divup((end - begin), num_threads);
39
+ int64_t begin_tid = begin + tid * chunk_size;
40
+ if (begin_tid < end) {
41
+ try {
42
+ internal::ThreadIdGuard tid_guard(tid);
43
+ f(begin_tid, std::min(end, chunk_size + begin_tid));
44
+ } catch (...) {
45
+ if (!err_flag.test_and_set()) {
46
+ eptr = std::current_exception();
47
+ }
48
+ }
49
+ }
50
+ }
51
+ if (eptr) {
52
+ std::rethrow_exception(eptr);
53
+ }
54
+ }
55
+ } // namespace internal
56
+ #endif // _OPENMP
57
+
58
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/PythonTorchFunctionTLS.h ADDED
@@ -0,0 +1,34 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/core/SafePyObject.h>
4
+ #include <c10/macros/Macros.h>
5
+
6
+ namespace at::impl {
7
+
8
+ enum TorchFunctionDisabledState { ENABLED, SUBCLASSES_DISABLED, ALL_DISABLED };
9
+
10
+ struct TORCH_API PythonTorchFunctionTLS {
11
+ static void set_disabled_state(TorchFunctionDisabledState disabled_state_);
12
+ static TorchFunctionDisabledState get_disabled_state();
13
+
14
+ static void push_onto_stack(std::shared_ptr<SafePyObject> mode);
15
+ static const std::shared_ptr<SafePyObject> pop_stack();
16
+ static const std::shared_ptr<SafePyObject>& get_stack_at(int64_t idx);
17
+ static int64_t stack_len();
18
+
19
+ static const PythonTorchFunctionTLS& get_state();
20
+ static void set_state(const PythonTorchFunctionTLS& state);
21
+
22
+ private:
23
+ // The mode TLS is split into
24
+ // - disabled_state, which says which part of torch function are disabled
25
+ // - stack_, which is a vector of modes representing the stack of user
26
+ // defined modes
27
+ TorchFunctionDisabledState disabled_state_ =
28
+ TorchFunctionDisabledState::ENABLED;
29
+ std::vector<std::shared_ptr<c10::SafePyObject>> stack_;
30
+ };
31
+
32
+ TORCH_API bool torch_function_mode_enabled();
33
+
34
+ } // namespace at::impl
videollama2/lib/python3.10/site-packages/torch/include/ATen/RedispatchFunctions.h ADDED
The diff for this file is too large to render. See raw diff
 
videollama2/lib/python3.10/site-packages/torch/include/ATen/SavedTensorHooks.h ADDED
@@ -0,0 +1,52 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/macros/Export.h>
4
+ #include <c10/util/Optional.h>
5
+ #include <c10/util/python_stub.h>
6
+ #include <stack>
7
+ #include <string>
8
+
9
+ #include <utility>
10
+
11
+ namespace at {
12
+
13
+ namespace impl {
14
+
15
+ struct TORCH_API SavedTensorDefaultHooksTLS {
16
+ // PyObject is defined in c10/util/python_stub.h
17
+ std::stack<std::pair<PyObject*, PyObject*>> stack;
18
+
19
+ // See NOTE: [Disabling SavedTensorDefaultHooks] for context
20
+ // NOTE: [disabled_error_message invariant]
21
+ // disabled_error_message is nullopt IFF Saved Tensor hooks is enabled
22
+ // We did this for efficiency (so we didn't have to keep a separate bool
23
+ // around)
24
+ c10::optional<std::string> disabled_error_message;
25
+ };
26
+
27
+ } // namespace impl
28
+
29
+ struct TORCH_API SavedTensorDefaultHooks {
30
+ static void push_hooks(PyObject* pack_hook, PyObject* unpack_hook);
31
+ static void pop_hooks();
32
+ static std::pair<PyObject*, PyObject*> get_hooks();
33
+ static void lazy_initialize();
34
+ static std::stack<std::pair<PyObject*, PyObject*>> get_stack();
35
+ static void set_stack(std::stack<std::pair<PyObject*, PyObject*>>);
36
+
37
+ static const impl::SavedTensorDefaultHooksTLS& get_tls_state();
38
+ static void set_tls_state(const impl::SavedTensorDefaultHooksTLS& tls);
39
+
40
+ // NOTE: [Disabling SavedTensorDefaultHooks]
41
+ // A developer of a PyTorch feature may choose to disable SavedTensorDefault
42
+ // hooks, especially if their feature does not work with it. If they are
43
+ // disabled, then the following will raise an error:
44
+ // - Attempting to push_hooks
45
+ // - calling disable(message) with a non-zero stack (from get_stack) size
46
+ static void disable(const std::string& error_message);
47
+ static void enable();
48
+ static bool is_enabled();
49
+ static const c10::optional<std::string>& get_disabled_error_message();
50
+ };
51
+
52
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/ScalarOps.h ADDED
@@ -0,0 +1,71 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/Tensor.h>
4
+ #include <c10/core/Scalar.h>
5
+
6
+ #ifndef AT_PER_OPERATOR_HEADERS
7
+ #include <ATen/Functions.h>
8
+ #else
9
+ #include <ATen/ops/scalar_tensor.h>
10
+ #endif
11
+
12
+ namespace at::detail {
13
+ // When filling a number to 1-element CPU tensor, we want to skip
14
+ // everything but manipulate data ptr directly.
15
+ // Ideally this fast pass should be implemented in TensorIterator,
16
+ // but we also want to skip compute_types which in not avoidable
17
+ // in TensorIterator for now.
18
+ Tensor& scalar_fill(Tensor& self, const Scalar& value);
19
+ TORCH_API Tensor scalar_tensor_static(
20
+ const Scalar& s,
21
+ c10::optional<ScalarType> dtype_opt,
22
+ c10::optional<Device> device_opt);
23
+ } // namespace at::detail
24
+
25
+ // This is in the c10 namespace because we use ADL to find the functions in it.
26
+ namespace c10 {
27
+
28
+ // FIXME: this should be (and was) Scalar::toTensor, but there is currently no
29
+ // way to implement this without going through Derived Types (which are not part
30
+ // of core).
31
+ inline at::Tensor scalar_to_tensor(
32
+ const Scalar& s,
33
+ const Device device = at::kCPU) {
34
+ // This is the fast track we have for CPU scalar tensors.
35
+ if (device == at::kCPU) {
36
+ if (s.isFloatingPoint()) {
37
+ return at::detail::scalar_tensor_static(s, at::kDouble, at::kCPU);
38
+ } else if (s.isComplex()) {
39
+ return at::detail::scalar_tensor_static(s, at::kComplexDouble, at::kCPU);
40
+ } else if (s.isBoolean()) {
41
+ return at::detail::scalar_tensor_static(s, at::kBool, at::kCPU);
42
+ } else {
43
+ AT_ASSERT(s.isIntegral(false));
44
+ return at::detail::scalar_tensor_static(s, at::kLong, at::kCPU);
45
+ }
46
+ }
47
+ if (s.isFloatingPoint()) {
48
+ return at::scalar_tensor(s, at::device(device).dtype(at::kDouble));
49
+ } else if (s.isBoolean()) {
50
+ return at::scalar_tensor(s, at::device(device).dtype(at::kBool));
51
+ } else if (s.isComplex()) {
52
+ return at::scalar_tensor(s, at::device(device).dtype(at::kComplexDouble));
53
+ } else {
54
+ AT_ASSERT(s.isIntegral(false));
55
+ return at::scalar_tensor(s, at::device(device).dtype(at::kLong));
56
+ }
57
+ }
58
+
59
+ } // namespace c10
60
+
61
+ namespace at::native {
62
+
63
+ inline Tensor wrapped_scalar_tensor(
64
+ const Scalar& scalar,
65
+ const Device device = at::kCPU) {
66
+ auto tensor = scalar_to_tensor(scalar, device);
67
+ tensor.unsafeGetTensorImpl()->set_wrapped_number(true);
68
+ return tensor;
69
+ }
70
+
71
+ } // namespace at::native
videollama2/lib/python3.10/site-packages/torch/include/ATen/SmallVector.h ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ #pragma once
2
+ #include <c10/util/SmallVector.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/SparseCsrTensorImpl.h ADDED
@@ -0,0 +1,182 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/Tensor.h>
4
+ #include <c10/core/TensorImpl.h>
5
+ #include <c10/util/Exception.h>
6
+ namespace at {
7
+
8
+ // Struct implementing a sparse CSR tensor. It uses three 1-D tensors for
9
+ // denoting the data: `crow_indices_`, `col_indices_` and `values_`.
10
+ // The `crow_indices_` tensor is a integer tensor of shape `(size(0) + 1)`
11
+ // that represents the compressed row indices of the CSR tensor. The
12
+ // `col_indices_` tensor is an integer tensor of shape `(nnz())`
13
+ // that explicitly stores the column indices of each value of the sparse
14
+ // tensor. The `values_` tensor can be of any pytorch-supported data type
15
+ // and has shape `(nnz())`.
16
+ //
17
+ // Since the main advantage of the CSR format over the COO format is speed of
18
+ // computation, care must be taken to facilitate smooth interfacing of
19
+ // these data structures with optimized libraries such as MKL and MAGMA.
20
+ // Since the MKL interface for pytorch currently uses indexing with int32
21
+ // type, it is important to make sure that the `crow_indices` and `col_indices`
22
+ // are of type int32 when calling MKL routines such as SPMM or SPMV.
23
+ //
24
+ // If not calling MKL, it should be alright to use 64 bit integer tensors
25
+ // for indexing.
26
+ struct TORCH_API SparseCsrTensorImpl : public TensorImpl {
27
+ Tensor crow_indices_;
28
+ Tensor col_indices_;
29
+ Tensor values_;
30
+ Layout layout_;
31
+
32
+ public:
33
+ explicit SparseCsrTensorImpl(
34
+ at::DispatchKeySet,
35
+ at::Device device,
36
+ Layout layout,
37
+ const caffe2::TypeMeta);
38
+
39
+ void resize_(int64_t nnz, IntArrayRef size);
40
+ void resize_and_clear_(
41
+ int64_t sparse_dim,
42
+ int64_t dense_dim,
43
+ IntArrayRef size);
44
+ void resize_as_sparse_compressed_tensor_(const Tensor& src);
45
+ void set_member_tensors(
46
+ const Tensor& crow_indices,
47
+ const Tensor& col_indices,
48
+ const Tensor& values,
49
+ IntArrayRef size);
50
+
51
+ const Tensor& compressed_indices() const {
52
+ return crow_indices_;
53
+ }
54
+ const Tensor& plain_indices() const {
55
+ return col_indices_;
56
+ }
57
+ const Tensor& values() const {
58
+ return values_;
59
+ }
60
+ int64_t nnz() {
61
+ return col_indices_.size(-1);
62
+ }
63
+
64
+ inline int64_t batch_dim() const noexcept {
65
+ return crow_indices_.dim() - 1;
66
+ }
67
+
68
+ inline int64_t sparse_dim() const noexcept {
69
+ return 2;
70
+ }
71
+
72
+ inline int64_t dense_dim() const noexcept {
73
+ return values_.dim() - batch_dim() - block_dim() - 1;
74
+ }
75
+
76
+ private:
77
+ inline int64_t block_dim() const noexcept {
78
+ return (layout_ == kSparseBsr || layout_ == kSparseBsc ? 2 : 0);
79
+ }
80
+
81
+ protected:
82
+ IntArrayRef strides_custom() const override;
83
+ SymIntArrayRef sym_strides_custom() const override;
84
+ bool is_contiguous_custom(MemoryFormat) const override;
85
+
86
+ public:
87
+ void set_size(int64_t dim, int64_t new_size) override;
88
+ void set_stride(int64_t dim, int64_t new_stride) override;
89
+ void set_storage_offset(int64_t storage_offset) override;
90
+ Layout layout_impl() const override {
91
+ return layout_;
92
+ }
93
+ void set_layout(Layout layout) {
94
+ switch (layout) {
95
+ case kSparseCsr:
96
+ case kSparseCsc:
97
+ case kSparseBsr:
98
+ case kSparseBsc:
99
+ layout_ = layout;
100
+ break;
101
+ default:
102
+ TORCH_CHECK(false, "unsupported layout ", layout);
103
+ }
104
+ }
105
+
106
+ /**
107
+ * Return a TensorImpl that is a shallow-copy of this TensorImpl.
108
+ *
109
+ * For usage of `version_counter` and `allow_tensor_metadata_change`,
110
+ * see NOTE [ TensorImpl Shallow-Copying ].
111
+ */
112
+ c10::intrusive_ptr<TensorImpl> shallow_copy_and_detach(
113
+ const c10::VariableVersion& version_counter,
114
+ bool allow_tensor_metadata_change) const override {
115
+ auto impl = c10::make_intrusive<SparseCsrTensorImpl>(
116
+ key_set(), device(), layout_impl(), dtype());
117
+ copy_tensor_metadata(
118
+ /*src_sparse_impl=*/this,
119
+ /*dest_sparse_impl=*/impl.get(),
120
+ /*version_counter=*/version_counter,
121
+ /*allow_tensor_metadata_change=*/allow_tensor_metadata_change);
122
+ impl->refresh_numel();
123
+ return impl;
124
+ }
125
+
126
+ /**
127
+ * Return a TensorImpl that is a shallow-copy of this TensorImpl.
128
+ *
129
+ * For usage of `version_counter` and `allow_tensor_metadata_change`,
130
+ * see NOTE [ TensorImpl Shallow-Copying ].
131
+ */
132
+ c10::intrusive_ptr<TensorImpl> shallow_copy_and_detach(
133
+ c10::VariableVersion&& version_counter,
134
+ bool allow_tensor_metadata_change) const override {
135
+ auto impl = c10::make_intrusive<SparseCsrTensorImpl>(
136
+ key_set(), device(), layout_impl(), dtype());
137
+ copy_tensor_metadata(
138
+ /*src_sparse_impl=*/this,
139
+ /*dest_sparse_impl=*/impl.get(),
140
+ /*version_counter=*/version_counter,
141
+ /*allow_tensor_metadata_change=*/allow_tensor_metadata_change);
142
+ impl->refresh_numel();
143
+ return impl;
144
+ }
145
+
146
+ private:
147
+ explicit SparseCsrTensorImpl(
148
+ at::DispatchKeySet key_set,
149
+ const caffe2::TypeMeta data_type,
150
+ at::Tensor crow_indices,
151
+ at::Tensor col_indices,
152
+ at::Tensor values,
153
+ at::Layout layout);
154
+
155
+ const char* tensorimpl_type_name() const override;
156
+
157
+ /**
158
+ * Copy the tensor metadata fields (e.g. sizes / strides / storage pointer /
159
+ * storage_offset) from one TensorImpl to another TensorImpl.
160
+ *
161
+ * For usage of `version_counter` and `allow_tensor_metadata_change`, see NOTE
162
+ * [ TensorImpl Shallow-Copying ].
163
+ */
164
+ static void copy_tensor_metadata(
165
+ const SparseCsrTensorImpl* src_sparse_impl,
166
+ SparseCsrTensorImpl* dest_sparse_impl,
167
+ const c10::VariableVersion& version_counter,
168
+ bool allow_tensor_metadata_change) {
169
+ TensorImpl::copy_tensor_metadata(
170
+ src_sparse_impl,
171
+ dest_sparse_impl,
172
+ version_counter,
173
+ allow_tensor_metadata_change);
174
+
175
+ // Sparse-specific fields
176
+ dest_sparse_impl->crow_indices_ = src_sparse_impl->compressed_indices();
177
+ dest_sparse_impl->col_indices_ = src_sparse_impl->plain_indices();
178
+ dest_sparse_impl->values_ = src_sparse_impl->values();
179
+ dest_sparse_impl->layout_ = src_sparse_impl->layout_impl();
180
+ }
181
+ };
182
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/SparseCsrTensorUtils.h ADDED
@@ -0,0 +1,415 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/SparseCsrTensorImpl.h>
4
+ #include <ATen/SparseTensorImpl.h>
5
+ #include <ATen/core/Tensor.h>
6
+
7
+ #ifndef AT_PER_OPERATOR_HEADERS
8
+ #include <ATen/Functions.h>
9
+ #include <ATen/NativeFunctions.h>
10
+ #include <ATen/Operators.h>
11
+ #else
12
+ #include <ATen/ops/_sparse_compressed_tensor_unsafe.h>
13
+ #include <ATen/ops/resize_as_sparse_native.h>
14
+ #endif
15
+
16
+ #define AT_DISPATCH_ALL_SPARSE_COMPRESSED_LAYOUTS(LAYOUT, NAME, ...) \
17
+ [&] { \
18
+ const auto& the_layout = LAYOUT; \
19
+ switch (the_layout) { \
20
+ case kSparseCsr: \
21
+ case kSparseCsc: \
22
+ case kSparseBsr: \
23
+ case kSparseBsc: \
24
+ return __VA_ARGS__(); \
25
+ default: \
26
+ AT_ERROR( \
27
+ NAME, \
28
+ " expected sparse compressed tensor layout but got ", \
29
+ the_layout); \
30
+ } \
31
+ }()
32
+
33
+ #define AT_DISPATCH_ROW_SPARSE_COMPRESSED_LAYOUTS( \
34
+ LAYOUT, NAME, ROW_DIM_ACTION, COLUMN_DIM_ACTION) \
35
+ [&]() { \
36
+ const auto& the_layout = LAYOUT; \
37
+ switch (the_layout) { \
38
+ case kSparseCsr: \
39
+ case kSparseBsr: \
40
+ return (ROW_DIM_ACTION)(); \
41
+ case kSparseCsc: \
42
+ case kSparseBsc: \
43
+ return (COLUMN_DIM_ACTION)(); \
44
+ default: \
45
+ AT_ERROR( \
46
+ NAME, \
47
+ " expected sparse compressed tensor layout but got ", \
48
+ the_layout); \
49
+ } \
50
+ }()
51
+
52
+ #define AT_DISPATCH_PLAIN_SPARSE_COMPRESSED_LAYOUTS( \
53
+ LAYOUT, NAME, NO_BLOCK_ACTION, BLOCK_ACTION) \
54
+ [&]() { \
55
+ const auto& the_layout = LAYOUT; \
56
+ switch (the_layout) { \
57
+ case kSparseCsr: \
58
+ case kSparseCsc: \
59
+ return (NO_BLOCK_ACTION)(); \
60
+ case kSparseBsr: \
61
+ case kSparseBsc: \
62
+ return (BLOCK_ACTION)(); \
63
+ default: \
64
+ AT_ERROR( \
65
+ NAME, \
66
+ " expected sparse compressed tensor layout but got ", \
67
+ the_layout); \
68
+ } \
69
+ }()
70
+
71
+ #define AT_DISPATCH_SPARSE_ROW_COMPRESSED_LAYOUTS( \
72
+ LAYOUT, NAME, ROW_DIM_ACTION) \
73
+ [&]() { \
74
+ const auto& the_layout = LAYOUT; \
75
+ switch (the_layout) { \
76
+ case kSparseCsr: \
77
+ case kSparseBsr: \
78
+ return (ROW_DIM_ACTION)(); \
79
+ default: \
80
+ AT_ERROR( \
81
+ NAME, \
82
+ " expected sparse row compressed tensor layout but got ", \
83
+ the_layout); \
84
+ } \
85
+ }()
86
+
87
+ #define AT_DISPATCH_SPARSE_COL_COMPRESSED_LAYOUTS( \
88
+ LAYOUT, NAME, COL_DIM_ACTION) \
89
+ [&]() { \
90
+ const auto& the_layout = LAYOUT; \
91
+ switch (the_layout) { \
92
+ case kSparseCsc: \
93
+ case kSparseBsc: \
94
+ return (COL_DIM_ACTION)(); \
95
+ default: \
96
+ AT_ERROR( \
97
+ NAME, \
98
+ " expected sparse column compressed tensor layout but got ", \
99
+ the_layout); \
100
+ } \
101
+ }()
102
+
103
+ #define AT_DISPATCH_SPARSE_COMPRESSED_NONBLOCK_LAYOUTS(LAYOUT, NAME, ACTION) \
104
+ [&]() { \
105
+ const auto& the_layout = LAYOUT; \
106
+ switch (the_layout) { \
107
+ case kSparseCsr: \
108
+ case kSparseCsc: \
109
+ return (ACTION)(); \
110
+ default: \
111
+ AT_ERROR( \
112
+ NAME, \
113
+ " expected sparse compressed (non-block) tensor layout but got ", \
114
+ the_layout); \
115
+ } \
116
+ }()
117
+
118
+ #define AT_DISPATCH_SPARSE_COMPRESSED_BLOCK_LAYOUTS(LAYOUT, NAME, ACTION) \
119
+ [&]() { \
120
+ const auto& the_layout = LAYOUT; \
121
+ switch (the_layout) { \
122
+ case kSparseBsr: \
123
+ case kSparseBsc: \
124
+ return (ACTION)(); \
125
+ default: \
126
+ AT_ERROR( \
127
+ NAME, \
128
+ " expected sparse compressed block tensor layout but got ", \
129
+ the_layout); \
130
+ } \
131
+ }()
132
+
133
+ #define AT_DISPATCH_SPARSE_VALUE_TYPES(TYPE, NAME, ...) \
134
+ AT_DISPATCH_SWITCH( \
135
+ TYPE, \
136
+ NAME, \
137
+ AT_DISPATCH_CASE_ALL_TYPES_AND_COMPLEX_AND4( \
138
+ kComplexHalf, kHalf, kBool, kBFloat16, __VA_ARGS__))
139
+
140
+ namespace at {
141
+ namespace sparse_csr {
142
+
143
+ using SparseCsrTensor = Tensor;
144
+
145
+ inline bool is_sparse_compressed(const Layout& layout) {
146
+ switch (layout) {
147
+ case kSparseCsr:
148
+ case kSparseCsc:
149
+ case kSparseBsr:
150
+ case kSparseBsc:
151
+ return true;
152
+ default:;
153
+ }
154
+ return false;
155
+ }
156
+
157
+ inline bool is_sparse_compressed(const Tensor& self) {
158
+ return is_sparse_compressed(self.layout());
159
+ }
160
+
161
+ inline SparseCsrTensorImpl* get_sparse_csr_impl(const SparseCsrTensor& self) {
162
+ AT_DISPATCH_ALL_SPARSE_COMPRESSED_LAYOUTS(
163
+ self.layout(), "get_sparse_csr_impl", [&] {});
164
+ return static_cast<SparseCsrTensorImpl*>(self.unsafeGetTensorImpl());
165
+ }
166
+
167
+ inline std::string layoutToString(
168
+ Layout layout,
169
+ bool upper = false,
170
+ bool lower = false) {
171
+ switch (layout) {
172
+ case kSparseCsr:
173
+ return (upper ? "CSR" : (lower ? "csr" : "Csr"));
174
+ case kSparseCsc:
175
+ return (upper ? "CSC" : (lower ? "csc" : "Csc"));
176
+ case kSparseBsr:
177
+ return (upper ? "BSR" : (lower ? "bsr" : "Bsr"));
178
+ case kSparseBsc:
179
+ return (upper ? "BSC" : (lower ? "bsc" : "Bsc"));
180
+ default:
181
+ TORCH_CHECK(false, "Not a sparse compressed layout:", layout);
182
+ return "";
183
+ }
184
+ }
185
+
186
+ inline bool isCompressedRow(Layout layout) {
187
+ return AT_DISPATCH_ROW_SPARSE_COMPRESSED_LAYOUTS(
188
+ layout, "isCompressedRow", [&] { return true; }, [&] { return false; });
189
+ }
190
+
191
+ inline bool isCompressedColumn(Layout layout) {
192
+ return AT_DISPATCH_ROW_SPARSE_COMPRESSED_LAYOUTS(
193
+ layout,
194
+ "isCompressedColumn",
195
+ [&] { return false; },
196
+ [&] { return true; });
197
+ }
198
+
199
+ inline std::string compressedIndicesName(Layout layout) {
200
+ return AT_DISPATCH_ROW_SPARSE_COMPRESSED_LAYOUTS(
201
+ layout,
202
+ "compressedIndicesName",
203
+ [&] { return "crow_indices"; },
204
+ [&] { return "ccol_indices"; });
205
+ }
206
+
207
+ inline std::string plainIndicesName(Layout layout) {
208
+ return AT_DISPATCH_ROW_SPARSE_COMPRESSED_LAYOUTS(
209
+ layout,
210
+ "plainIndicesName",
211
+ [&] { return "col_indices"; },
212
+ [&] { return "row_indices"; });
213
+ }
214
+
215
+ inline std::string compressedDimName(Layout layout) {
216
+ switch (layout) {
217
+ case kSparseCsr:
218
+ return "row";
219
+ case kSparseCsc:
220
+ return "column";
221
+ case kSparseBsr:
222
+ return "row block";
223
+ case kSparseBsc:
224
+ return "column block";
225
+ default:
226
+ TORCH_CHECK(false, "Not a sparse compressed layout:", layout);
227
+ return "";
228
+ }
229
+ }
230
+
231
+ inline std::string plainDimName(Layout layout) {
232
+ switch (layout) {
233
+ case kSparseCsr:
234
+ return "column";
235
+ case kSparseCsc:
236
+ return "row";
237
+ case kSparseBsr:
238
+ return "column block";
239
+ case kSparseBsc:
240
+ return "row block";
241
+ default:
242
+ TORCH_CHECK(false, "Not a sparse compressed layout:", layout);
243
+ return "";
244
+ }
245
+ }
246
+
247
+ inline int rowDimension(Layout layout, IntArrayRef size) {
248
+ return size.size() - (isCompressedRow(layout) ? 2 : 1);
249
+ }
250
+
251
+ inline int columnDimension(Layout layout, IntArrayRef size) {
252
+ return size.size() - (isCompressedColumn(layout) ? 2 : 1);
253
+ }
254
+
255
+ inline int compressedDimension(
256
+ Layout layout,
257
+ IntArrayRef size,
258
+ size_t dense_ndim = 0) {
259
+ return size.size() - dense_ndim - (isCompressedRow(layout) ? 2 : 1);
260
+ }
261
+
262
+ inline int plainDimension(
263
+ Layout layout,
264
+ IntArrayRef size,
265
+ size_t dense_ndim = 0) {
266
+ return size.size() - dense_ndim - (isCompressedRow(layout) ? 1 : 2);
267
+ }
268
+
269
+ inline int64_t numBatchDimensions(Tensor const& self) {
270
+ return AT_DISPATCH_ROW_SPARSE_COMPRESSED_LAYOUTS(
271
+ self.layout(),
272
+ "numBatchDimensions",
273
+ [&self] { return self.crow_indices().dim() - 1; },
274
+ [&self] { return self.ccol_indices().dim() - 1; });
275
+ }
276
+
277
+ inline std::pair<Tensor, Tensor> getCompressedPlainIndices(Tensor const& self) {
278
+ return AT_DISPATCH_ROW_SPARSE_COMPRESSED_LAYOUTS(
279
+ self.layout(),
280
+ "getCompressedPlainIndices",
281
+ [&self] {
282
+ return std::make_pair(self.crow_indices(), self.col_indices());
283
+ },
284
+ [&self] {
285
+ return std::make_pair(self.ccol_indices(), self.row_indices());
286
+ });
287
+ }
288
+
289
+ inline Layout flip_compressed_layout(Layout layout) {
290
+ switch (layout) {
291
+ case kSparseCsr:
292
+ return kSparseCsc;
293
+ case kSparseCsc:
294
+ return kSparseCsr;
295
+ case kSparseBsr:
296
+ return kSparseBsc;
297
+ case kSparseBsc:
298
+ return kSparseBsr;
299
+ default:
300
+ TORCH_CHECK(false, "Not a sparse compressed layout:", layout);
301
+ return kSparseCsr;
302
+ }
303
+ }
304
+
305
+ inline DimVector getBlockSize(Tensor const& self) {
306
+ int64_t n_batch = numBatchDimensions(self);
307
+ return at::DimVector(self.values().sizes().slice(n_batch + 1, 2));
308
+ }
309
+
310
+ inline at::OptionalArray<at::SymInt> getSymIntBlockSize(Tensor const& self) {
311
+ if (self.layout() == at::kSparseBsr || self.layout() == at::kSparseBsc) {
312
+ int64_t n_batch = numBatchDimensions(self);
313
+ return self.values().sym_sizes().slice(n_batch + 1, 2).vec();
314
+ } else {
315
+ return {};
316
+ }
317
+ }
318
+
319
+ template <typename binary_op_t, typename binary_op_out_t>
320
+ inline bool only_sparse_compressed_binary_op_trivial_cases(
321
+ const Tensor& self,
322
+ const Tensor& other,
323
+ const Scalar& alpha,
324
+ Tensor& out,
325
+ const binary_op_t& binary_op,
326
+ const binary_op_out_t& binary_op_out) {
327
+ // Only sparse compressed! Just like the name says :)
328
+ TORCH_INTERNAL_ASSERT(at::sparse_csr::is_sparse_compressed(self));
329
+ TORCH_INTERNAL_ASSERT(at::sparse_csr::is_sparse_compressed(other));
330
+ TORCH_INTERNAL_ASSERT(at::sparse_csr::is_sparse_compressed(out));
331
+
332
+ // Bypass BLAS if there are matches in (self, other, out)
333
+ if (self.is_same(out) && self.is_same(other)) {
334
+ binary_op_out(self.values(), other.values(), alpha);
335
+ return true;
336
+ }
337
+ if (self.is_same(other)) {
338
+ Tensor compressed_indices, plain_indices;
339
+ std::tie(compressed_indices, plain_indices) =
340
+ at::sparse_csr::getCompressedPlainIndices(self);
341
+ static_cast<SparseCsrTensorImpl*>(out.unsafeGetTensorImpl())
342
+ ->set_member_tensors(
343
+ compressed_indices,
344
+ plain_indices,
345
+ binary_op(self.values(), other.values(), alpha),
346
+ self.sizes());
347
+ return true;
348
+ }
349
+ return false;
350
+ }
351
+
352
+ inline bool only_sparse_compressed_add_trivial_cases(
353
+ const Tensor& self,
354
+ const Tensor& other,
355
+ const Scalar& alpha,
356
+ Tensor& out) {
357
+ return only_sparse_compressed_binary_op_trivial_cases(
358
+ self,
359
+ other,
360
+ alpha,
361
+ out,
362
+ [](const Tensor& v1, const Tensor& v2, const Scalar& alpha) {
363
+ return v1.add(v2, alpha);
364
+ },
365
+ [](const Tensor& v1, const Tensor& v2, const Scalar& alpha) {
366
+ return v1.add_(v2, alpha);
367
+ });
368
+ }
369
+
370
+ inline Tensor to_type(Tensor input, ScalarType dtype) {
371
+ Tensor compressed_indices, plain_indices;
372
+ std::tie(compressed_indices, plain_indices) =
373
+ at::sparse_csr::getCompressedPlainIndices(input);
374
+ return at::_sparse_compressed_tensor_unsafe(
375
+ std::move(compressed_indices),
376
+ std::move(plain_indices),
377
+ std::move(input.values()).to(dtype),
378
+ input.sizes(),
379
+ dtype,
380
+ input.layout(),
381
+ input.device(),
382
+ input.options().pinned_memory_opt());
383
+ }
384
+
385
+ template <typename acc_t, typename scalar_t>
386
+ inline std::tuple<Tensor, Tensor> create_acc_buffer(
387
+ TensorOptions option,
388
+ ScalarType type,
389
+ int64_t nnz = -1) {
390
+ Tensor new_values, new_values_acc;
391
+ constexpr bool need_acc = !std::is_same<scalar_t, acc_t>::value;
392
+ bool is_integral = at::isIntegralType(type, /*includeBool=*/true);
393
+ if constexpr (need_acc) {
394
+ auto acc_dtype = CppTypeToScalarType<acc_t>::value;
395
+ new_values_acc = at::empty({}, option.dtype(acc_dtype));
396
+ new_values = is_integral ? new_values_acc : at::empty({}, option);
397
+ } else {
398
+ new_values = new_values_acc = at::empty({}, option);
399
+ }
400
+ if (nnz != -1) {
401
+ return std::make_tuple(
402
+ new_values.resize_(nnz), new_values_acc.resize_(nnz));
403
+ } else {
404
+ return std::make_tuple(new_values, new_values_acc);
405
+ }
406
+ }
407
+
408
+ inline void copy_from_acc_buffer(Tensor& new_values, Tensor& new_values_acc) {
409
+ if (!new_values_acc.is_same(new_values)) {
410
+ new_values.copy_(new_values_acc);
411
+ }
412
+ }
413
+
414
+ } // namespace sparse_csr
415
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/Storage.h ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ #pragma once
2
+ #include <c10/core/Storage.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/StorageUtils.h ADDED
@@ -0,0 +1,49 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <c10/core/Storage.h>
4
+ #include <c10/core/StorageImpl.h>
5
+ #include <c10/util/intrusive_ptr.h>
6
+
7
+ namespace at {
8
+
9
+ class TensorBase;
10
+
11
+ // Here we define a series of utils to create/manipulate ATen backed
12
+ // c10 storage implementations.
13
+
14
+ /**
15
+ * Create a new shared memory storage impl managed by file descriptor
16
+ *
17
+ * @param size size in bytes
18
+ */
19
+ C10_EXPORT c10::intrusive_ptr<c10::StorageImpl> new_shm_fd_storage(size_t size);
20
+
21
+ /**
22
+ * Copy src to dst
23
+ * Caller must guarantee the validness of the storage objects
24
+ * during the entire copy process, esp. when it's async.
25
+ *
26
+ * This can probably live in c10 namespace later if needed,
27
+ * but for now keep it in at to keep implementation simple.
28
+ *
29
+ * @param dst dst tensor
30
+ * @param src src tensor
31
+ * @param non_blocking (default false) whether this operation blocks caller
32
+ */
33
+ C10_EXPORT void storage_copy(
34
+ c10::Storage& dst,
35
+ const c10::Storage& src,
36
+ bool non_blocking = false);
37
+
38
+ /**
39
+ * In place change the storage to shm based.
40
+ *
41
+ * This is only applicable to CPU tensors not already shared.
42
+ * Otherwise, it's a no op to mirror the THP tensor behavior:
43
+ * https://pytorch.org/docs/stable/generated/torch.Tensor.share_memory_.html
44
+ *
45
+ * @param t a tensor
46
+ */
47
+ C10_EXPORT void share_memory_(TensorBase& t);
48
+
49
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/TensorAccessor.h ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ #pragma once
2
+ #include <ATen/core/TensorAccessor.h>
videollama2/lib/python3.10/site-packages/torch/include/ATen/TensorIteratorInternal.h ADDED
@@ -0,0 +1,72 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ #include <ATen/native/TensorIterator.h>
3
+ #include <c10/util/SmallBuffer.h>
4
+ #include <c10/util/irange.h>
5
+
6
+ namespace at {
7
+
8
+ struct DimCounter {
9
+ DimCounter(IntArrayRef shape, Range range);
10
+
11
+ void increment(const std::array<int64_t, 2>& step);
12
+ bool is_done() const;
13
+ std::array<int64_t, 2> max_2d_step() const;
14
+
15
+ IntArrayRef shape;
16
+ Range range;
17
+ c10::SmallBuffer<int64_t, 4> values;
18
+ int64_t offset;
19
+ };
20
+
21
+ namespace internal {
22
+
23
+ inline void get_data_ptrs(
24
+ char** ptrs,
25
+ ArrayRef<char*> base,
26
+ IntArrayRef strides,
27
+ IntArrayRef counter) {
28
+ const int64_t ntensors = base.size();
29
+ const int64_t ndim = counter.size();
30
+ std::copy(base.begin(), base.end(), ptrs);
31
+ for (const auto dim : c10::irange(ndim)) {
32
+ int64_t value = counter[dim];
33
+ for (const auto arg : c10::irange(ntensors)) {
34
+ ptrs[arg] += value * strides[dim * ntensors + arg];
35
+ }
36
+ }
37
+ }
38
+
39
+ inline void serial_for_each(
40
+ IntArrayRef shape,
41
+ IntArrayRef strides,
42
+ char** base_ptrs,
43
+ size_t ntensors,
44
+ typename TensorIteratorBase::loop2d_t loop,
45
+ Range range) {
46
+ const auto ndim = shape.size();
47
+ TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
48
+ strides.size() == ntensors * std::max(size_t{2}, ndim));
49
+
50
+ if (ndim <= 1) {
51
+ if (range.begin == 0) {
52
+ loop(base_ptrs, strides.data(), range.size(), 1);
53
+ } else {
54
+ c10::SmallBuffer<char*, 4> ptrs(ntensors);
55
+ get_data_ptrs(ptrs.data(), {base_ptrs, ntensors}, strides, {range.begin});
56
+ loop(ptrs.data(), strides.data(), range.size(), 1);
57
+ }
58
+ } else {
59
+ c10::SmallBuffer<char*, 4> ptrs(ntensors);
60
+ auto counter = DimCounter(shape, range);
61
+ while (!counter.is_done()) {
62
+ get_data_ptrs(
63
+ ptrs.data(), {base_ptrs, ntensors}, strides, counter.values);
64
+ auto step = counter.max_2d_step();
65
+ loop(ptrs.data(), strides.data(), step[0], step[1]);
66
+ counter.increment(step);
67
+ }
68
+ }
69
+ }
70
+
71
+ } // namespace internal
72
+ } // namespace at
videollama2/lib/python3.10/site-packages/torch/include/ATen/TensorOperators.h ADDED
@@ -0,0 +1,54 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ #include <ATen/core/Tensor.h>
4
+ #include <c10/core/Scalar.h>
5
+
6
+ #ifndef AT_PER_OPERATOR_HEADERS
7
+ #include <ATen/Functions.h>
8
+ #else
9
+ #include <ATen/ops/empty_like.h>
10
+ #endif
11
+
12
+ #include <stdexcept>
13
+ #include <string>
14
+
15
+ namespace at {
16
+
17
+ #define AT_FORALL_BINARY_OPS(_) \
18
+ _(+, x.add(y), y.add(x)) \
19
+ _(*, x.mul(y), y.mul(x)) \
20
+ _(-, \
21
+ x.sub(y), \
22
+ ::at::empty_like(y, at::MemoryFormat::Preserve).fill_(x).sub_(y)) \
23
+ _(/, \
24
+ x.div(y), \
25
+ ::at::empty_like(y, at::MemoryFormat::Preserve).fill_(x).div_(y)) \
26
+ _(%, \
27
+ x.remainder(y), \
28
+ ::at::empty_like(y, at::MemoryFormat::Preserve).fill_(x).remainder_(y)) \
29
+ _(&, x.bitwise_and(y), y.bitwise_and(x)) \
30
+ _(|, x.bitwise_or(y), y.bitwise_or(x)) \
31
+ _(^, x.bitwise_xor(y), y.bitwise_xor(x)) \
32
+ _(<, x.lt(y), y.gt(x)) \
33
+ _(<=, x.le(y), y.ge(x)) \
34
+ _(>, x.gt(y), y.lt(x)) \
35
+ _(>=, x.ge(y), y.le(x)) \
36
+ _(==, x.eq(y), y.eq(x)) \
37
+ _(!=, x.ne(y), y.ne(x))
38
+
39
+ #define DEFINE_OPERATOR(op, body, reverse_scalar_body) \
40
+ static inline Tensor operator op(const Tensor& x, const Tensor& y) { \
41
+ return body; \
42
+ } \
43
+ static inline Tensor operator op(const Tensor& x, const Scalar& y) { \
44
+ return body; \
45
+ } \
46
+ static inline Tensor operator op(const Scalar& x, const Tensor& y) { \
47
+ return reverse_scalar_body; \
48
+ }
49
+
50
+ AT_FORALL_BINARY_OPS(DEFINE_OPERATOR)
51
+ #undef DEFINE_OPERATOR
52
+ #undef AT_FORALL_BINARY_OPS
53
+
54
+ } // namespace at