ADAPT-Chase commited on
Commit
b7e3da0
·
verified ·
1 Parent(s): 2da6f25

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. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_gather_stats_with_counts_native.h +22 -0
  2. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_gather_stats_with_counts_ops.h +40 -0
  3. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_native.h +21 -0
  4. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_ops.h +29 -0
  5. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats.h +40 -0
  6. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_compositeexplicitautograd_dispatch.h +24 -0
  7. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_cuda_dispatch.h +23 -0
  8. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_native.h +22 -0
  9. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_ops.h +40 -0
  10. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats.h +40 -0
  11. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_compositeexplicitautograd_dispatch.h +24 -0
  12. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_cpu_dispatch.h +23 -0
  13. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_cuda_dispatch.h +23 -0
  14. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_native.h +23 -0
  15. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_ops.h +40 -0
  16. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli.h +68 -0
  17. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_compositeexplicitautograd_dispatch.h +28 -0
  18. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_compositeexplicitautogradnonfunctional_dispatch.h +23 -0
  19. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_cpu_dispatch.h +26 -0
  20. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_cuda_dispatch.h +26 -0
  21. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_meta_dispatch.h +24 -0
  22. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_native.h +28 -0
  23. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_ops.h +106 -0
  24. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear.h +31 -0
  25. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear_compositeimplicitautograd_dispatch.h +23 -0
  26. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear_native.h +21 -0
  27. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear_ops.h +29 -0
  28. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy.h +40 -0
  29. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward.h +40 -0
  30. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_cpu_dispatch.h +25 -0
  31. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_cuda_dispatch.h +25 -0
  32. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_native.h +24 -0
  33. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_ops.h +40 -0
  34. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_cpu_dispatch.h +25 -0
  35. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_cuda_dispatch.h +25 -0
  36. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_native.h +24 -0
  37. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_ops.h +40 -0
  38. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits.h +40 -0
  39. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits_compositeexplicitautograd_dispatch.h +25 -0
  40. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits_native.h +22 -0
  41. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits_ops.h +40 -0
  42. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount.h +40 -0
  43. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_compositeexplicitautograd_dispatch.h +24 -0
  44. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_cpu_dispatch.h +23 -0
  45. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_cuda_dispatch.h +23 -0
  46. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_native.h +23 -0
  47. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_ops.h +40 -0
  48. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binomial.h +40 -0
  49. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binomial_compositeexplicitautograd_dispatch.h +24 -0
  50. tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binomial_cpu_dispatch.h +23 -0
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_gather_stats_with_counts_native.h ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_gather_stats_with_counts_out(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts, at::Tensor & out0, at::Tensor & out1);
20
+ TORCH_API ::std::tuple<at::Tensor,at::Tensor> batch_norm_gather_stats_with_counts_cuda(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts);
21
+ } // namespace native
22
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_gather_stats_with_counts_ops.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API batch_norm_gather_stats_with_counts {
19
+ using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, double, double, const at::Tensor &);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::batch_norm_gather_stats_with_counts";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "batch_norm_gather_stats_with_counts(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, Tensor counts) -> (Tensor, Tensor)";
25
+ static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts);
26
+ static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts);
27
+ };
28
+
29
+ struct TORCH_API batch_norm_gather_stats_with_counts_out {
30
+ using schema = ::std::tuple<at::Tensor &,at::Tensor &> (const at::Tensor &, const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, double, double, const at::Tensor &, at::Tensor &, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::batch_norm_gather_stats_with_counts";
34
+ static constexpr const char* overload_name = "out";
35
+ static constexpr const char* schema_str = "batch_norm_gather_stats_with_counts.out(Tensor input, Tensor mean, Tensor invstd, Tensor? running_mean, Tensor? running_var, float momentum, float eps, Tensor counts, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))";
36
+ static ::std::tuple<at::Tensor &,at::Tensor &> call(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts, at::Tensor & out0, at::Tensor & out1);
37
+ static ::std::tuple<at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts, at::Tensor & out0, at::Tensor & out1);
38
+ };
39
+
40
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_native.h ADDED
@@ -0,0 +1,21 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API at::Tensor batch_norm(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double momentum, double eps, bool cudnn_enabled);
20
+ } // namespace native
21
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_ops.h ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API batch_norm {
19
+ using schema = at::Tensor (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, bool, double, double, bool);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::batch_norm";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor? running_mean, Tensor? running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> Tensor";
25
+ static at::Tensor call(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double momentum, double eps, bool cudnn_enabled);
26
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double momentum, double eps, bool cudnn_enabled);
27
+ };
28
+
29
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/batch_norm_stats_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::batch_norm_stats(Tensor input, float eps) -> (Tensor, Tensor)
27
+ inline ::std::tuple<at::Tensor,at::Tensor> batch_norm_stats(const at::Tensor & input, double eps) {
28
+ return at::_ops::batch_norm_stats::call(input, eps);
29
+ }
30
+
31
+ // aten::batch_norm_stats.out(Tensor input, float eps, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
32
+ inline ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_stats_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, double eps) {
33
+ return at::_ops::batch_norm_stats_out::call(input, eps, out0, out1);
34
+ }
35
+ // aten::batch_norm_stats.out(Tensor input, float eps, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
36
+ inline ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_stats_outf(const at::Tensor & input, double eps, at::Tensor & out0, at::Tensor & out1) {
37
+ return at::_ops::batch_norm_stats_out::call(input, eps, out0, out1);
38
+ }
39
+
40
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_compositeexplicitautograd_dispatch.h ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeexplicitautograd {
19
+
20
+ TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_stats_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, double eps);
21
+ TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_stats_outf(const at::Tensor & input, double eps, at::Tensor & out0, at::Tensor & out1);
22
+
23
+ } // namespace compositeexplicitautograd
24
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_cuda_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cuda {
19
+
20
+ TORCH_API ::std::tuple<at::Tensor,at::Tensor> batch_norm_stats(const at::Tensor & input, double eps);
21
+
22
+ } // namespace cuda
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_native.h ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_stats_out(const at::Tensor & input, double eps, at::Tensor & out0, at::Tensor & out1);
20
+ TORCH_API ::std::tuple<at::Tensor,at::Tensor> batch_norm_stats_cuda(const at::Tensor & input, double eps);
21
+ } // namespace native
22
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_stats_ops.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API batch_norm_stats {
19
+ using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, double);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::batch_norm_stats";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "batch_norm_stats(Tensor input, float eps) -> (Tensor, Tensor)";
25
+ static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & input, double eps);
26
+ static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, double eps);
27
+ };
28
+
29
+ struct TORCH_API batch_norm_stats_out {
30
+ using schema = ::std::tuple<at::Tensor &,at::Tensor &> (const at::Tensor &, double, at::Tensor &, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::batch_norm_stats";
34
+ static constexpr const char* overload_name = "out";
35
+ static constexpr const char* schema_str = "batch_norm_stats.out(Tensor input, float eps, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))";
36
+ static ::std::tuple<at::Tensor &,at::Tensor &> call(const at::Tensor & input, double eps, at::Tensor & out0, at::Tensor & out1);
37
+ static ::std::tuple<at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, double eps, at::Tensor & out0, at::Tensor & out1);
38
+ };
39
+
40
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/batch_norm_update_stats_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::batch_norm_update_stats(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum) -> (Tensor, Tensor)
27
+ inline ::std::tuple<at::Tensor,at::Tensor> batch_norm_update_stats(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum) {
28
+ return at::_ops::batch_norm_update_stats::call(input, running_mean, running_var, momentum);
29
+ }
30
+
31
+ // aten::batch_norm_update_stats.out(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
32
+ inline ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_update_stats_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum) {
33
+ return at::_ops::batch_norm_update_stats_out::call(input, running_mean, running_var, momentum, out0, out1);
34
+ }
35
+ // aten::batch_norm_update_stats.out(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
36
+ inline ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_update_stats_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, at::Tensor & out0, at::Tensor & out1) {
37
+ return at::_ops::batch_norm_update_stats_out::call(input, running_mean, running_var, momentum, out0, out1);
38
+ }
39
+
40
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_compositeexplicitautograd_dispatch.h ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeexplicitautograd {
19
+
20
+ TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_update_stats_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum);
21
+ TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_update_stats_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, at::Tensor & out0, at::Tensor & out1);
22
+
23
+ } // namespace compositeexplicitautograd
24
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_cpu_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cpu {
19
+
20
+ TORCH_API ::std::tuple<at::Tensor,at::Tensor> batch_norm_update_stats(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum);
21
+
22
+ } // namespace cpu
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_cuda_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cuda {
19
+
20
+ TORCH_API ::std::tuple<at::Tensor,at::Tensor> batch_norm_update_stats(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum);
21
+
22
+ } // namespace cuda
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_native.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> batch_norm_update_stats_out(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, at::Tensor & out0, at::Tensor & out1);
20
+ TORCH_API ::std::tuple<at::Tensor,at::Tensor> batch_norm_update_stats_cpu(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum);
21
+ TORCH_API ::std::tuple<at::Tensor,at::Tensor> batch_norm_update_stats_cuda(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum);
22
+ } // namespace native
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/batch_norm_update_stats_ops.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API batch_norm_update_stats {
19
+ using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, double);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::batch_norm_update_stats";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "batch_norm_update_stats(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum) -> (Tensor, Tensor)";
25
+ static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum);
26
+ static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum);
27
+ };
28
+
29
+ struct TORCH_API batch_norm_update_stats_out {
30
+ using schema = ::std::tuple<at::Tensor &,at::Tensor &> (const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, double, at::Tensor &, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::batch_norm_update_stats";
34
+ static constexpr const char* overload_name = "out";
35
+ static constexpr const char* schema_str = "batch_norm_update_stats.out(Tensor input, Tensor? running_mean, Tensor? running_var, float momentum, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))";
36
+ static ::std::tuple<at::Tensor &,at::Tensor &> call(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, at::Tensor & out0, at::Tensor & out1);
37
+ static ::std::tuple<at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, at::Tensor & out0, at::Tensor & out1);
38
+ };
39
+
40
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli.h ADDED
@@ -0,0 +1,68 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/bernoulli_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::bernoulli(Tensor self, *, Generator? generator=None) -> Tensor
27
+ inline at::Tensor bernoulli(const at::Tensor & self, ::std::optional<at::Generator> generator=::std::nullopt) {
28
+ return at::_ops::bernoulli::call(self, generator);
29
+ }
30
+
31
+ // aten::bernoulli.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
32
+ inline at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Generator> generator=::std::nullopt) {
33
+ return at::_ops::bernoulli_out::call(self, generator, out);
34
+ }
35
+ // aten::bernoulli.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
36
+ inline at::Tensor & bernoulli_outf(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
37
+ return at::_ops::bernoulli_out::call(self, generator, out);
38
+ }
39
+
40
+ // aten::bernoulli.p(Tensor self, float p, *, Generator? generator=None) -> Tensor
41
+ inline at::Tensor bernoulli(const at::Tensor & self, double p, ::std::optional<at::Generator> generator=::std::nullopt) {
42
+ return at::_ops::bernoulli_p::call(self, p, generator);
43
+ }
44
+
45
+ // aten::bernoulli.Tensor_out(Tensor self, Tensor p, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
46
+ inline at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt) {
47
+ return at::_ops::bernoulli_Tensor_out::call(self, p, generator, out);
48
+ }
49
+ // aten::bernoulli.Tensor_out(Tensor self, Tensor p, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
50
+ inline at::Tensor & bernoulli_outf(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator, at::Tensor & out) {
51
+ return at::_ops::bernoulli_Tensor_out::call(self, p, generator, out);
52
+ }
53
+
54
+ // aten::bernoulli.Tensor(Tensor self, Tensor p, *, Generator? generator=None) -> Tensor
55
+ inline at::Tensor bernoulli(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt) {
56
+ return at::_ops::bernoulli_Tensor::call(self, p, generator);
57
+ }
58
+
59
+ // aten::bernoulli.float_out(Tensor self, float p=0.5, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
60
+ inline at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, double p=0.5, ::std::optional<at::Generator> generator=::std::nullopt) {
61
+ return at::_ops::bernoulli_float_out::call(self, p, generator, out);
62
+ }
63
+ // aten::bernoulli.float_out(Tensor self, float p=0.5, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)
64
+ inline at::Tensor & bernoulli_outf(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out) {
65
+ return at::_ops::bernoulli_float_out::call(self, p, generator, out);
66
+ }
67
+
68
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_compositeexplicitautograd_dispatch.h ADDED
@@ -0,0 +1,28 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeexplicitautograd {
19
+
20
+ TORCH_API at::Tensor bernoulli(const at::Tensor & self, ::std::optional<at::Generator> generator=::std::nullopt);
21
+ TORCH_API at::Tensor bernoulli(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt);
22
+ TORCH_API at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt);
23
+ TORCH_API at::Tensor & bernoulli_outf(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator, at::Tensor & out);
24
+ TORCH_API at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, double p=0.5, ::std::optional<at::Generator> generator=::std::nullopt);
25
+ TORCH_API at::Tensor & bernoulli_outf(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out);
26
+
27
+ } // namespace compositeexplicitautograd
28
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_compositeexplicitautogradnonfunctional_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeexplicitautogradnonfunctional {
19
+
20
+ TORCH_API at::Tensor bernoulli(const at::Tensor & self, double p, ::std::optional<at::Generator> generator=::std::nullopt);
21
+
22
+ } // namespace compositeexplicitautogradnonfunctional
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_cpu_dispatch.h ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cpu {
19
+
20
+ TORCH_API at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Generator> generator=::std::nullopt);
21
+ TORCH_API at::Tensor & bernoulli_outf(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out);
22
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt);
23
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, double p=0.5, ::std::optional<at::Generator> generator=::std::nullopt);
24
+
25
+ } // namespace cpu
26
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_cuda_dispatch.h ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cuda {
19
+
20
+ TORCH_API at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Generator> generator=::std::nullopt);
21
+ TORCH_API at::Tensor & bernoulli_outf(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out);
22
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt);
23
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, double p=0.5, ::std::optional<at::Generator> generator=::std::nullopt);
24
+
25
+ } // namespace cuda
26
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_meta_dispatch.h ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace meta {
19
+
20
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt);
21
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, double p=0.5, ::std::optional<at::Generator> generator=::std::nullopt);
22
+
23
+ } // namespace meta
24
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_native.h ADDED
@@ -0,0 +1,28 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API at::Tensor bernoulli(const at::Tensor & self, ::std::optional<at::Generator> generator=::std::nullopt);
20
+ TORCH_API at::Tensor & bernoulli_out(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out);
21
+ TORCH_API at::Tensor bernoulli(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt);
22
+ TORCH_API at::Tensor & bernoulli_Tensor_out(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator, at::Tensor & out);
23
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator=::std::nullopt);
24
+ TORCH_API at::Tensor & bernoulli_float_out(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out);
25
+ TORCH_API at::Tensor & bernoulli_(at::Tensor & self, double p=0.5, ::std::optional<at::Generator> generator=::std::nullopt);
26
+ TORCH_API at::Tensor bernoulli(const at::Tensor & self, double p, ::std::optional<at::Generator> generator=::std::nullopt);
27
+ } // namespace native
28
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bernoulli_ops.h ADDED
@@ -0,0 +1,106 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API bernoulli {
19
+ using schema = at::Tensor (const at::Tensor &, ::std::optional<at::Generator>);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::bernoulli";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "bernoulli(Tensor self, *, Generator? generator=None) -> Tensor";
25
+ static at::Tensor call(const at::Tensor & self, ::std::optional<at::Generator> generator);
26
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, ::std::optional<at::Generator> generator);
27
+ };
28
+
29
+ struct TORCH_API bernoulli_out {
30
+ using schema = at::Tensor & (const at::Tensor &, ::std::optional<at::Generator>, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::bernoulli";
34
+ static constexpr const char* overload_name = "out";
35
+ static constexpr const char* schema_str = "bernoulli.out(Tensor self, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)";
36
+ static at::Tensor & call(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out);
37
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out);
38
+ };
39
+
40
+ struct TORCH_API bernoulli__Tensor {
41
+ using schema = at::Tensor & (at::Tensor &, const at::Tensor &, ::std::optional<at::Generator>);
42
+ using ptr_schema = schema*;
43
+ // See Note [static constexpr char* members for windows NVCC]
44
+ static constexpr const char* name = "aten::bernoulli_";
45
+ static constexpr const char* overload_name = "Tensor";
46
+ static constexpr const char* schema_str = "bernoulli_.Tensor(Tensor(a!) self, Tensor p, *, Generator? generator=None) -> Tensor(a!)";
47
+ static at::Tensor & call(at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator);
48
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator);
49
+ };
50
+
51
+ struct TORCH_API bernoulli__float {
52
+ using schema = at::Tensor & (at::Tensor &, double, ::std::optional<at::Generator>);
53
+ using ptr_schema = schema*;
54
+ // See Note [static constexpr char* members for windows NVCC]
55
+ static constexpr const char* name = "aten::bernoulli_";
56
+ static constexpr const char* overload_name = "float";
57
+ static constexpr const char* schema_str = "bernoulli_.float(Tensor(a!) self, float p=0.5, *, Generator? generator=None) -> Tensor(a!)";
58
+ static at::Tensor & call(at::Tensor & self, double p, ::std::optional<at::Generator> generator);
59
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, double p, ::std::optional<at::Generator> generator);
60
+ };
61
+
62
+ struct TORCH_API bernoulli_p {
63
+ using schema = at::Tensor (const at::Tensor &, double, ::std::optional<at::Generator>);
64
+ using ptr_schema = schema*;
65
+ // See Note [static constexpr char* members for windows NVCC]
66
+ static constexpr const char* name = "aten::bernoulli";
67
+ static constexpr const char* overload_name = "p";
68
+ static constexpr const char* schema_str = "bernoulli.p(Tensor self, float p, *, Generator? generator=None) -> Tensor";
69
+ static at::Tensor call(const at::Tensor & self, double p, ::std::optional<at::Generator> generator);
70
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double p, ::std::optional<at::Generator> generator);
71
+ };
72
+
73
+ struct TORCH_API bernoulli_Tensor_out {
74
+ using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, ::std::optional<at::Generator>, at::Tensor &);
75
+ using ptr_schema = schema*;
76
+ // See Note [static constexpr char* members for windows NVCC]
77
+ static constexpr const char* name = "aten::bernoulli";
78
+ static constexpr const char* overload_name = "Tensor_out";
79
+ static constexpr const char* schema_str = "bernoulli.Tensor_out(Tensor self, Tensor p, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)";
80
+ static at::Tensor & call(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator, at::Tensor & out);
81
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator, at::Tensor & out);
82
+ };
83
+
84
+ struct TORCH_API bernoulli_Tensor {
85
+ using schema = at::Tensor (const at::Tensor &, const at::Tensor &, ::std::optional<at::Generator>);
86
+ using ptr_schema = schema*;
87
+ // See Note [static constexpr char* members for windows NVCC]
88
+ static constexpr const char* name = "aten::bernoulli";
89
+ static constexpr const char* overload_name = "Tensor";
90
+ static constexpr const char* schema_str = "bernoulli.Tensor(Tensor self, Tensor p, *, Generator? generator=None) -> Tensor";
91
+ static at::Tensor call(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator);
92
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator);
93
+ };
94
+
95
+ struct TORCH_API bernoulli_float_out {
96
+ using schema = at::Tensor & (const at::Tensor &, double, ::std::optional<at::Generator>, at::Tensor &);
97
+ using ptr_schema = schema*;
98
+ // See Note [static constexpr char* members for windows NVCC]
99
+ static constexpr const char* name = "aten::bernoulli";
100
+ static constexpr const char* overload_name = "float_out";
101
+ static constexpr const char* schema_str = "bernoulli.float_out(Tensor self, float p=0.5, *, Generator? generator=None, Tensor(a!) out) -> Tensor(a!)";
102
+ static at::Tensor & call(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out);
103
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out);
104
+ };
105
+
106
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear.h ADDED
@@ -0,0 +1,31 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/bilinear_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::bilinear(Tensor input1, Tensor input2, Tensor weight, Tensor? bias=None) -> Tensor
27
+ inline at::Tensor bilinear(const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias={}) {
28
+ return at::_ops::bilinear::call(input1, input2, weight, bias);
29
+ }
30
+
31
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear_compositeimplicitautograd_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeimplicitautograd {
19
+
20
+ TORCH_API at::Tensor bilinear(const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias={});
21
+
22
+ } // namespace compositeimplicitautograd
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear_native.h ADDED
@@ -0,0 +1,21 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API at::Tensor bilinear(const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias={});
20
+ } // namespace native
21
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bilinear_ops.h ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API bilinear {
19
+ using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::bilinear";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "bilinear(Tensor input1, Tensor input2, Tensor weight, Tensor? bias=None) -> Tensor";
25
+ static at::Tensor call(const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias);
26
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input1, const at::Tensor & input2, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias);
27
+ };
28
+
29
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/binary_cross_entropy_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::binary_cross_entropy(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor
27
+ inline at::Tensor binary_cross_entropy(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean) {
28
+ return at::_ops::binary_cross_entropy::call(self, target, weight, reduction);
29
+ }
30
+
31
+ // aten::binary_cross_entropy.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
32
+ inline at::Tensor & binary_cross_entropy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean) {
33
+ return at::_ops::binary_cross_entropy_out::call(self, target, weight, reduction, out);
34
+ }
35
+ // aten::binary_cross_entropy.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
36
+ inline at::Tensor & binary_cross_entropy_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out) {
37
+ return at::_ops::binary_cross_entropy_out::call(self, target, weight, reduction, out);
38
+ }
39
+
40
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/binary_cross_entropy_backward_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::binary_cross_entropy_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor
27
+ inline at::Tensor binary_cross_entropy_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean) {
28
+ return at::_ops::binary_cross_entropy_backward::call(grad_output, self, target, weight, reduction);
29
+ }
30
+
31
+ // aten::binary_cross_entropy_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!)
32
+ inline at::Tensor & binary_cross_entropy_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean) {
33
+ return at::_ops::binary_cross_entropy_backward_grad_input::call(grad_output, self, target, weight, reduction, grad_input);
34
+ }
35
+ // aten::binary_cross_entropy_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!)
36
+ inline at::Tensor & binary_cross_entropy_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & grad_input) {
37
+ return at::_ops::binary_cross_entropy_backward_grad_input::call(grad_output, self, target, weight, reduction, grad_input);
38
+ }
39
+
40
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_cpu_dispatch.h ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cpu {
19
+
20
+ TORCH_API at::Tensor binary_cross_entropy_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
21
+ TORCH_API at::Tensor & binary_cross_entropy_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
22
+ TORCH_API at::Tensor & binary_cross_entropy_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & grad_input);
23
+
24
+ } // namespace cpu
25
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_cuda_dispatch.h ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cuda {
19
+
20
+ TORCH_API at::Tensor binary_cross_entropy_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
21
+ TORCH_API at::Tensor & binary_cross_entropy_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
22
+ TORCH_API at::Tensor & binary_cross_entropy_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & grad_input);
23
+
24
+ } // namespace cuda
25
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_native.h ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API at::Tensor binary_cross_entropy_backward_cpu(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
20
+ TORCH_API at::Tensor & binary_cross_entropy_backward_out_cpu(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & grad_input);
21
+ TORCH_API at::Tensor binary_cross_entropy_backward_cuda(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
22
+ TORCH_API at::Tensor & binary_cross_entropy_backward_out_cuda(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & grad_input);
23
+ } // namespace native
24
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_backward_ops.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API binary_cross_entropy_backward {
19
+ using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, int64_t);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::binary_cross_entropy_backward";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "binary_cross_entropy_backward(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor";
25
+ static at::Tensor call(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction);
26
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction);
27
+ };
28
+
29
+ struct TORCH_API binary_cross_entropy_backward_grad_input {
30
+ using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, int64_t, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::binary_cross_entropy_backward";
34
+ static constexpr const char* overload_name = "grad_input";
35
+ static constexpr const char* schema_str = "binary_cross_entropy_backward.grad_input(Tensor grad_output, Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) grad_input) -> Tensor(a!)";
36
+ static at::Tensor & call(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & grad_input);
37
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & grad_input);
38
+ };
39
+
40
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_cpu_dispatch.h ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cpu {
19
+
20
+ TORCH_API at::Tensor binary_cross_entropy(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
21
+ TORCH_API at::Tensor & binary_cross_entropy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
22
+ TORCH_API at::Tensor & binary_cross_entropy_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out);
23
+
24
+ } // namespace cpu
25
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_cuda_dispatch.h ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cuda {
19
+
20
+ TORCH_API at::Tensor binary_cross_entropy(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
21
+ TORCH_API at::Tensor & binary_cross_entropy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
22
+ TORCH_API at::Tensor & binary_cross_entropy_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out);
23
+
24
+ } // namespace cuda
25
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_native.h ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API at::Tensor binary_cross_entropy_cpu(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
20
+ TORCH_API at::Tensor & binary_cross_entropy_out_cpu(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out);
21
+ TORCH_API at::Tensor binary_cross_entropy_cuda(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean);
22
+ TORCH_API at::Tensor & binary_cross_entropy_out_cuda(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out);
23
+ } // namespace native
24
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_ops.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API binary_cross_entropy {
19
+ using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, int64_t);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::binary_cross_entropy";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "binary_cross_entropy(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean) -> Tensor";
25
+ static at::Tensor call(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction);
26
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction);
27
+ };
28
+
29
+ struct TORCH_API binary_cross_entropy_out {
30
+ using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, int64_t, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::binary_cross_entropy";
34
+ static constexpr const char* overload_name = "out";
35
+ static constexpr const char* schema_str = "binary_cross_entropy.out(Tensor self, Tensor target, Tensor? weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)";
36
+ static at::Tensor & call(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out);
37
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, int64_t reduction, at::Tensor & out);
38
+ };
39
+
40
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/binary_cross_entropy_with_logits_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::binary_cross_entropy_with_logits(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean) -> Tensor
27
+ inline at::Tensor binary_cross_entropy_with_logits(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, const ::std::optional<at::Tensor> & pos_weight={}, int64_t reduction=at::Reduction::Mean) {
28
+ return at::_ops::binary_cross_entropy_with_logits::call(self, target, weight, pos_weight, reduction);
29
+ }
30
+
31
+ // aten::binary_cross_entropy_with_logits.out(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
32
+ inline at::Tensor & binary_cross_entropy_with_logits_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, const ::std::optional<at::Tensor> & pos_weight={}, int64_t reduction=at::Reduction::Mean) {
33
+ return at::_ops::binary_cross_entropy_with_logits_out::call(self, target, weight, pos_weight, reduction, out);
34
+ }
35
+ // aten::binary_cross_entropy_with_logits.out(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)
36
+ inline at::Tensor & binary_cross_entropy_with_logits_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction, at::Tensor & out) {
37
+ return at::_ops::binary_cross_entropy_with_logits_out::call(self, target, weight, pos_weight, reduction, out);
38
+ }
39
+
40
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits_compositeexplicitautograd_dispatch.h ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeexplicitautograd {
19
+
20
+ TORCH_API at::Tensor binary_cross_entropy_with_logits(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, const ::std::optional<at::Tensor> & pos_weight={}, int64_t reduction=at::Reduction::Mean);
21
+ TORCH_API at::Tensor & binary_cross_entropy_with_logits_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, const ::std::optional<at::Tensor> & pos_weight={}, int64_t reduction=at::Reduction::Mean);
22
+ TORCH_API at::Tensor & binary_cross_entropy_with_logits_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction, at::Tensor & out);
23
+
24
+ } // namespace compositeexplicitautograd
25
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits_native.h ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API at::Tensor binary_cross_entropy_with_logits(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight={}, const ::std::optional<at::Tensor> & pos_weight={}, int64_t reduction=at::Reduction::Mean);
20
+ TORCH_API at::Tensor & binary_cross_entropy_with_logits_out(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction, at::Tensor & out);
21
+ } // namespace native
22
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binary_cross_entropy_with_logits_ops.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API binary_cross_entropy_with_logits {
19
+ using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, int64_t);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::binary_cross_entropy_with_logits";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "binary_cross_entropy_with_logits(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean) -> Tensor";
25
+ static at::Tensor call(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction);
26
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction);
27
+ };
28
+
29
+ struct TORCH_API binary_cross_entropy_with_logits_out {
30
+ using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const ::std::optional<at::Tensor> &, const ::std::optional<at::Tensor> &, int64_t, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::binary_cross_entropy_with_logits";
34
+ static constexpr const char* overload_name = "out";
35
+ static constexpr const char* schema_str = "binary_cross_entropy_with_logits.out(Tensor self, Tensor target, Tensor? weight=None, Tensor? pos_weight=None, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)";
36
+ static at::Tensor & call(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction, at::Tensor & out);
37
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction, at::Tensor & out);
38
+ };
39
+
40
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/bincount_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::bincount(Tensor self, Tensor? weights=None, int minlength=0) -> Tensor
27
+ inline at::Tensor bincount(const at::Tensor & self, const ::std::optional<at::Tensor> & weights={}, int64_t minlength=0) {
28
+ return at::_ops::bincount::call(self, weights, minlength);
29
+ }
30
+
31
+ // aten::bincount.out(Tensor self, Tensor? weights=None, int minlength=0, *, Tensor(a!) out) -> Tensor(a!)
32
+ inline at::Tensor & bincount_out(at::Tensor & out, const at::Tensor & self, const ::std::optional<at::Tensor> & weights={}, int64_t minlength=0) {
33
+ return at::_ops::bincount_out::call(self, weights, minlength, out);
34
+ }
35
+ // aten::bincount.out(Tensor self, Tensor? weights=None, int minlength=0, *, Tensor(a!) out) -> Tensor(a!)
36
+ inline at::Tensor & bincount_outf(const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out) {
37
+ return at::_ops::bincount_out::call(self, weights, minlength, out);
38
+ }
39
+
40
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_compositeexplicitautograd_dispatch.h ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeexplicitautograd {
19
+
20
+ TORCH_API at::Tensor & bincount_out(at::Tensor & out, const at::Tensor & self, const ::std::optional<at::Tensor> & weights={}, int64_t minlength=0);
21
+ TORCH_API at::Tensor & bincount_outf(const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out);
22
+
23
+ } // namespace compositeexplicitautograd
24
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_cpu_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cpu {
19
+
20
+ TORCH_API at::Tensor bincount(const at::Tensor & self, const ::std::optional<at::Tensor> & weights={}, int64_t minlength=0);
21
+
22
+ } // namespace cpu
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_cuda_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cuda {
19
+
20
+ TORCH_API at::Tensor bincount(const at::Tensor & self, const ::std::optional<at::Tensor> & weights={}, int64_t minlength=0);
21
+
22
+ } // namespace cuda
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_native.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from NativeFunction.h
4
+
5
+ #include <c10/core/Scalar.h>
6
+ #include <c10/core/Storage.h>
7
+ #include <c10/core/TensorOptions.h>
8
+ #include <c10/util/Deprecated.h>
9
+ #include <optional>
10
+ #include <c10/core/QScheme.h>
11
+ #include <ATen/core/Reduction.h>
12
+ #include <ATen/core/Tensor.h>
13
+ #include <tuple>
14
+ #include <vector>
15
+
16
+
17
+ namespace at {
18
+ namespace native {
19
+ TORCH_API at::Tensor & bincount_out(const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out);
20
+ TORCH_API at::Tensor _bincount_cpu(const at::Tensor & self, const ::std::optional<at::Tensor> & weights={}, int64_t minlength=0);
21
+ TORCH_API at::Tensor _bincount_cuda(const at::Tensor & self, const ::std::optional<at::Tensor> & weights={}, int64_t minlength=0);
22
+ } // namespace native
23
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/bincount_ops.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Operator.h
4
+
5
+ #include <string_view>
6
+ #include <tuple>
7
+ #include <vector>
8
+
9
+ // Forward declarations of any types needed in the operator signatures.
10
+ // We can't directly include these classes because it will cause circular include dependencies.
11
+ // This file is included by TensorBody.h, which defines the Tensor class.
12
+ #include <ATen/core/ATen_fwd.h>
13
+
14
+ namespace at {
15
+ namespace _ops {
16
+
17
+
18
+ struct TORCH_API bincount {
19
+ using schema = at::Tensor (const at::Tensor &, const ::std::optional<at::Tensor> &, int64_t);
20
+ using ptr_schema = schema*;
21
+ // See Note [static constexpr char* members for windows NVCC]
22
+ static constexpr const char* name = "aten::bincount";
23
+ static constexpr const char* overload_name = "";
24
+ static constexpr const char* schema_str = "bincount(Tensor self, Tensor? weights=None, int minlength=0) -> Tensor";
25
+ static at::Tensor call(const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength);
26
+ static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength);
27
+ };
28
+
29
+ struct TORCH_API bincount_out {
30
+ using schema = at::Tensor & (const at::Tensor &, const ::std::optional<at::Tensor> &, int64_t, at::Tensor &);
31
+ using ptr_schema = schema*;
32
+ // See Note [static constexpr char* members for windows NVCC]
33
+ static constexpr const char* name = "aten::bincount";
34
+ static constexpr const char* overload_name = "out";
35
+ static constexpr const char* schema_str = "bincount.out(Tensor self, Tensor? weights=None, int minlength=0, *, Tensor(a!) out) -> Tensor(a!)";
36
+ static at::Tensor & call(const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out);
37
+ static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out);
38
+ };
39
+
40
+ }} // namespace at::_ops
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binomial.h ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+
3
+ // @generated by torchgen/gen.py from Function.h
4
+
5
+ #include <ATen/Context.h>
6
+ #include <ATen/DeviceGuard.h>
7
+ #include <ATen/TensorUtils.h>
8
+ #include <ATen/TracerMode.h>
9
+ #include <ATen/core/Generator.h>
10
+ #include <ATen/core/Reduction.h>
11
+ #include <ATen/core/Tensor.h>
12
+ #include <c10/core/Scalar.h>
13
+ #include <c10/core/Storage.h>
14
+ #include <c10/core/TensorOptions.h>
15
+ #include <c10/util/Deprecated.h>
16
+ #include <optional>
17
+ #include <string_view>
18
+
19
+
20
+
21
+ #include <ATen/ops/binomial_ops.h>
22
+
23
+ namespace at {
24
+
25
+
26
+ // aten::binomial(Tensor count, Tensor prob, Generator? generator=None) -> Tensor
27
+ inline at::Tensor binomial(const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator=::std::nullopt) {
28
+ return at::_ops::binomial::call(count, prob, generator);
29
+ }
30
+
31
+ // aten::binomial.out(Tensor count, Tensor prob, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!)
32
+ inline at::Tensor & binomial_out(at::Tensor & out, const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator=::std::nullopt) {
33
+ return at::_ops::binomial_out::call(count, prob, generator, out);
34
+ }
35
+ // aten::binomial.out(Tensor count, Tensor prob, Generator? generator=None, *, Tensor(a!) out) -> Tensor(a!)
36
+ inline at::Tensor & binomial_outf(const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator, at::Tensor & out) {
37
+ return at::_ops::binomial_out::call(count, prob, generator, out);
38
+ }
39
+
40
+ }
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binomial_compositeexplicitautograd_dispatch.h ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace compositeexplicitautograd {
19
+
20
+ TORCH_API at::Tensor & binomial_out(at::Tensor & out, const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator=::std::nullopt);
21
+ TORCH_API at::Tensor & binomial_outf(const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator, at::Tensor & out);
22
+
23
+ } // namespace compositeexplicitautograd
24
+ } // namespace at
tool_server/.venv/lib/python3.12/site-packages/torch/include/ATen/ops/binomial_cpu_dispatch.h ADDED
@@ -0,0 +1,23 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #pragma once
2
+ // @generated by torchgen/gen.py from DispatchKeyFunction.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
+ // Forward declarations of any types needed in the operator signatures.
12
+ // We can't directly include these classes because it will cause circular include dependencies.
13
+ // This file is included by TensorBody.h, which defines the Tensor class.
14
+ #include <ATen/core/ATen_fwd.h>
15
+
16
+ namespace at {
17
+
18
+ namespace cpu {
19
+
20
+ TORCH_API at::Tensor binomial(const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator=::std::nullopt);
21
+
22
+ } // namespace cpu
23
+ } // namespace at