mirror of
https://github.com/pytorch/pytorch.git
synced 2025-10-22 22:25:10 +08:00
026cfe85b4
Summary: Pull Request resolved: https://github.com/pytorch/pytorch/pull/61791 methods from forward During inlining we attached InlinedCallstack to nodes being inlined. In the process we attach moodule information as well, such that if CallMethod is being inlined we know which class instance and class type the method belongs to. However, CallMethod can be calling a method of the same object to which the graph belongs. e.g.: ``` def forward(self, input): x = input + 10 return forward_impl_(x, input) ``` Here forward_impl is method defined on the same class in which forward is defined. Existing module hierarchy annotation will mislabel this as unknown instance since the method is not associated with output of GetAttr node (it would be we had called self.conv.forward_impl_ for example). Change in this PR reconciles this by creating a placeholder name "SELF" for module instance indicating that you can traverse InlinedCallStack backwards to find first node with name != SELF, which would be the name of the object. e.g.: TOP(ResNet)::forward.SELF(ResNet)::_forward_impl.layer1(Sequential)::forward.0(BasicBlock)::forward.conv1(Conv2d)::forward.SELF(Conv2d)::_conv_forward Test Plan: Add test Imported from OSS Reviewed By: larryliu0820 Differential Revision: D29745443 fbshipit-source-id: 1525e41df53913341c4c36a56772454782a0ba93
53 lines
1.7 KiB
C++
53 lines
1.7 KiB
C++
#pragma once
|
|
|
|
#include <torch/csrc/jit/ir/ir.h>
|
|
#include <torch/csrc/utils/object_ptr.h>
|
|
|
|
namespace torch {
|
|
namespace jit {
|
|
|
|
void initPythonIRBindings(PyObject* module);
|
|
|
|
// execute a Python function, used for Ops we can't optimize but that we want to
|
|
// optimize around
|
|
struct ConcretePythonOp : public PythonOp {
|
|
static Symbol Kind;
|
|
|
|
ConcretePythonOp(Graph* graph) : PythonOp(graph, ::c10::prim::PythonOp) {}
|
|
ConcretePythonOp* init(
|
|
THPObjectPtr&& pyobj,
|
|
const std::string& cconv,
|
|
pyobj_list&& scalar_args) {
|
|
this->pyobj = std::move(pyobj);
|
|
this->scalar_args = std::move(scalar_args);
|
|
this->cconv = cconv;
|
|
return this;
|
|
}
|
|
// The Python object which contains the implementation of this function.
|
|
// This is either a class (non-legacy) or an object (legacy). See
|
|
// TraceInterpreterState for execution semantics.
|
|
THPObjectPtr pyobj;
|
|
// The calling convention for the Python function.
|
|
// 'c' -- constant argument
|
|
// 'd' -- dynamic argument
|
|
std::string cconv;
|
|
// Scalar arguments to the Python function. Not necessarily passed to
|
|
// the function in this order; see cconv for the correct order.
|
|
std::vector<THPObjectPtr> scalar_args;
|
|
|
|
std::string name() const override;
|
|
void cloneFrom(Node* other_) override;
|
|
Node* allocNewInstance(Graph* g) override {
|
|
return new ConcretePythonOp(g);
|
|
}
|
|
// recover the autograd.Function instance, if this PythonOp's function
|
|
// was originally SomeFunction.apply
|
|
// used in ONNX for discovering symbolics
|
|
c10::optional<THPObjectPtr> autogradFunction() const override;
|
|
void writeScalars(std::ostream& out) const override;
|
|
void lint_python() const override;
|
|
};
|
|
|
|
} // namespace jit
|
|
} // namespace torch
|