1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
#pragma once
#include <torch/csrc/Export.h>
#include <torch/csrc/autograd/InferenceMode.h>
#include <torch/csrc/autograd/autograd.h>
#include <torch/csrc/autograd/function.h>
#include <torch/csrc/autograd/variable.h>
#include <torch/csrc/utils/variadic.h>
#include <ATen/core/Tensor.h>
#include <functional>
#include <memory>
#include <vector>
namespace torch {
namespace autograd {
using function_constructor = std::function<std::shared_ptr<Node>(edge_list&&)>;
/**
* Wraps the tensor outputs in variables and creates the grad_fn and sets the
* grad_fn if necessary.
*/
TORCH_API variable_list wrap_outputs(
const variable_list& inputs,
tensor_list&& outputs,
const function_constructor& ctr);
/// Checks that inputs contains exactly `args` items and that the first
/// `required_args`
/// items are not nullptr. If not specified, `required_args` defaults to `args`.
TORCH_API void check_input_variables(
const char* name,
const variable_list& inputs,
int args,
int required_args = -1,
bool allow_undefined = false);
struct ComputeRequiresGrad : IterArgs<ComputeRequiresGrad> {
bool out = false;
using IterArgs<ComputeRequiresGrad>::operator();
void operator()(const at::Tensor& tensor) {
const auto& var = static_cast<const Variable&>(tensor);
if (var.defined() && var.requires_grad()) {
out = true;
}
}
void operator()(const c10::optional<at::Tensor>& tensor) {
if (tensor.has_value()) {
(*this)(*tensor);
}
}
bool short_circuit() {
return out;
}
};
template <typename... Args>
inline bool compute_requires_grad(Args&&... args) {
if (!GradMode::is_enabled()) {
return false;
}
return ComputeRequiresGrad().apply(std::forward<Args>(args)...).out;
}
inline void set_history(
at::Tensor& variable,
const std::shared_ptr<Node>& grad_fn) {
AT_ASSERT(grad_fn);
if (variable.defined()) {
// If the codegen triggers this, you most likely want to add your newly
// added function to the DONT_REQUIRE_DERIVATIVE list in
// tools/autograd/gen_variable_type.py
TORCH_INTERNAL_ASSERT(isDifferentiableType(variable.scalar_type()));
auto output_nr = grad_fn->add_input_metadata(variable);
impl::set_gradient_edge(variable, {grad_fn, output_nr});
} else {
grad_fn->add_input_metadata(Node::undefined_input());
}
}
inline void set_history(
std::vector<Variable>&& variables,
const std::shared_ptr<Node>& grad_fn) {
for (auto& variable : variables) {
set_history(variable, grad_fn);
}
}
inline void set_history(
std::vector<Variable>& variables,
const std::shared_ptr<Node>& grad_fn) {
for (auto& variable : variables) {
set_history(variable, grad_fn);
}
}
inline bool isFwGradDefined(const c10::optional<at::Tensor>& t) {
return t.has_value() && t->defined() && t->_fw_grad(/*level */ 0).defined();
}
inline bool isFwGradDefinedTensorList(const at::ITensorListRef& variables) {
bool ret = false;
for (auto& variable : variables) {
ret |= isFwGradDefined(variable);
}
return ret;
}
inline bool isFwGradDefinedTensorList(
const c10::List<c10::optional<at::Tensor>> li) {
bool ret = false;
for (auto i : c10::irange(li.size())) {
auto t = li.get(i);
ret |= (t.has_value() && isFwGradDefined(t.value()));
}
return ret;
}
} // namespace autograd
} // namespace torch
|
