Revert D23798016: [FX] s/get_param/get_attr/

Test Plan: revert-hammer

Differential Revision:
D23798016 (pytorch@c941dd3)

Original commit changeset: 1d2f3db1994a

fbshipit-source-id: 974d930064b37d396c5d66c905a63d45449813e5

Author: James Reed

test/fx/quantization.py

@@ -222,7 +222,7 @@ def load_arg(a):
         for node in self.graph.nodes:
             if node.op == 'placeholder':
                 result = next(args_iter)
-            elif node.op == 'get_attr':
+            elif node.op == 'get_param':
                 result = self.state_dict[node.target]
             elif node.op == 'call_function':
                 result = node.target(*load_arg(node.args), **load_arg(node.kwargs))

test/test_fx.py

@@ -336,7 +336,7 @@ def __init__(self, interpreter):
                 placeholder_nodes.append(graph.create_node('placeholder', name))
 
             # Get the interpreter object
-            interpreter_node = graph.create_node('get_attr', 'interpreter')
+            interpreter_node = graph.create_node('get_param', 'interpreter')
 
             # Add a node to call the interpreter instance
             output_node = graph.create_node(
@@ -567,7 +567,7 @@ def test_graph_fns(self):
         g = Graph()
         a = g.placeholder('a')
         b = g.call_module('linear', (a,))
-        c = g.get_attr('bias')
+        c = g.get_param('bias')
         d = g.call_method('add', (b, c))
         e = g.call_function(torch.sin, (d,))
         g.output(e)
@@ -584,7 +584,7 @@ def test_construct_root_dict(self):
         graph : torch.fx.Graph = torch.fx.Graph()
         a : torch.fx.Node = graph.create_node('placeholder', 'x')
         b : torch.fx.Node = graph.create_node('call_module', 'foo.bar.baz', args=(a,))
-        c : torch.fx.Node = graph.create_node('get_attr', 'zip.zap.zam')
+        c : torch.fx.Node = graph.create_node('get_param', 'zip.zap.zam')
         d : torch.fx.Node = graph.create_node('call_function', operator.add, args=(b, c))
         graph.output(d)
 

torch/fx/__init__.py

@@ -36,7 +36,7 @@ def forward(self, x):
 opcode         name           target                                                   args                kwargs
 -------------  -------------  -------------------------------------------------------  ------------------  -----------
 placeholder    x              x                                                        ()                  {}
-get_attr       linear_weight  linear.weight                                            ()                  {}
+get_param      linear_weight  linear.weight                                            ()                  {}
 call_function  add_1          <built-in function add>                                  (x, linear_weight)  {}
 call_module    linear_1       linear                                                   (add_1,)            {}
 call_method    relu_2         relu                                                     [linear_1]          {}
@@ -48,7 +48,7 @@ def forward(self, x):
 
 - `placeholder` represents a function input. The `name` attribute specifies the name this value will take on.
   `target` is similarly the name of the argument. `args` and `kwargs` are don't-care
-- `get_attr` retrieves a parameter from the module hierarchy. `name` is similarly the name the result of the
+- `get_param` retrieves a parameter from the module hierarchy. `name` is similarly the name the result of the
    fetch is assigned to. `target` is the fully-qualified name of the parameter's position in the module hierarchy.
    `args` and `kwargs` are don't-care
 - `call_function` applies a free function to some values. `name` is similarly the name of the value to assign

torch/fx/graph.py

@@ -80,7 +80,7 @@ def create_node(self, op: str, target: Target,
                     args: Optional[Tuple[Argument, ...]] = None,
                     kwargs: Optional[Dict[str, Argument]] = None,
                     name: Optional[str] = None) -> Node:
-        assert op in ('call_function', 'call_method', 'get_attr', 'call_module', 'placeholder')
+        assert op in ('call_function', 'call_method', 'get_param', 'call_module', 'placeholder')
         args = () if args is None else args
         kwargs = {} if kwargs is None else kwargs
         self._mark_uses(args)
@@ -93,8 +93,8 @@ def create_node(self, op: str, target: Target,
     def placeholder(self, name: str) -> Node:
         return self.create_node('placeholder', name)
 
-    def get_attr(self, name: str) -> Node:
-        return self.create_node('get_attr', name)
+    def get_param(self, name: str) -> Node:
+        return self.create_node('get_param', name)
 
     def call_module(self,
                     module_name: str,
@@ -196,7 +196,7 @@ def python_code(self, root_module: str) -> Tuple[str, str, List[str]]:
                 assert isinstance(node.target, str)
                 body.append(f'{node.name} = {_format_target(root_module, node.target)}({_format_args(node.args, node.kwargs)})\n')
                 continue
-            elif node.op == 'get_attr':
+            elif node.op == 'get_param':
                 assert isinstance(node.target, str)
                 body.append(f'{node.name} = {_format_target(root_module, node.target)}\n')
                 continue
@@ -230,7 +230,7 @@ def format_node(n : Node) -> Optional[str]:
                 assert isinstance(n.target, str)
                 placeholder_names.append(n.target)
                 return None
-            elif n.op == 'get_attr':
+            elif n.op == 'get_param':
                 return f'%{n.name} : [uses={n.uses}] = self.{n.target}'
             else:
                 return f'%{n.name} : [uses={n.uses}] = {n.op}[target={n.target}](' \

torch/fx/graph_module.py

@@ -124,13 +124,13 @@ def __init__(self, root: Union[torch.nn.Module, Dict[str, Any]], graph: Graph):
             if hasattr(root, 'training'):
                 self.training = root.training
             for node in graph.nodes:
-                if node.op in ['get_attr', 'call_module']:
+                if node.op in ['get_param', 'call_module']:
                     assert isinstance(node.target, str)
                     _copy_attr(root, self, node.target)
         elif isinstance(root, dict):
             targets_to_copy = []
             for node in graph.nodes:
-                if node.op in ['get_attr', 'call_module']:
+                if node.op in ['get_param', 'call_module']:
                     assert isinstance(node.target, str)
                     if node.target not in root:
                         raise RuntimeError('Node ' + str(node) + ' referenced target ' + node.target +

torch/fx/symbolic_trace.py

@@ -55,15 +55,15 @@ def create_arg(self, a: Any) -> Argument:
         if isinstance(a, torch.nn.Parameter):
             for n, p in self.root.named_parameters():
                 if a is p:
-                    return self.create_node('get_attr', n, (), {})
+                    return self.create_node('get_param', n, (), {})
             raise NameError('parameter is not a member of this module')
         # Tensors do not have a reliable string repr() from which they can be
         # constructed (and we probably don't want to rely on that, either), so
         # for any constant Tensor values we encounter, first search for if they
         # are an attribute of some module in the module hierarchy. If so, emit
-        # a get_attr to retrieve that tensor. Otherwise, we'll store away the
+        # a get_param to retrieve that tensor. Otherwise, we'll store away the
         # tensor value into a special attribute on the Module s.t. we can
-        # retrieve it with a get_attr.
+        # retrieve it with a get_param.
         if isinstance(a, torch.Tensor):
             # TODO: slow
             def search_for_tensor(m : torch.nn.Module) -> Optional[List[str]]:
@@ -96,7 +96,7 @@ def search_for_tensor(m : torch.nn.Module) -> Optional[List[str]]:
                     i += 1
                 setattr(self.root, qualname, a)
 
-            return self.create_node('get_attr', qualname, (), {})
+            return self.create_node('get_param', qualname, (), {})
         return super().create_arg(a)
 
     def is_leaf_module(self, m: torch.nn.Module, module_qualified_name : str) -> bool:

torch/quantization/fx/quantize.py

@@ -177,7 +177,7 @@ def get_qconfig(module):
 
         self.qconfig_map = dict()
         for node in input_graph.nodes:
-            if node.op == 'get_attr':
+            if node.op == 'get_param':
                 parent, _ = _parent_name(node.target)
                 self.qconfig_map[node.name] = get_qconfig(self.modules[parent])
             elif node.op == 'call_function':
@@ -557,7 +557,7 @@ def load_arg(a):
                 setattr(quantized_root, packed_weight_name, packed_weight)
                 # replace prepack node with a getattr node
                 env[node.name] = folded_graph.create_node(
-                    'get_attr', packed_weight_name, (), {})
+                    'get_param', packed_weight_name, (), {})
             elif prepack_node is not None:
                 # remove the foled node
                 continue

torch/quantization/fx/utils.py

@@ -17,7 +17,7 @@ def graph_pretty_str(g, shorten=True) -> str:
     built_in_meth_re = re.compile('<built-in method (.*) of type.*>')
     op_dict = {
         'placeholder': 'plchdr',
-        'get_attr': 'gt_prm',
+        'get_param': 'gt_prm',
         'call_function': 'cl_fun',
         'call_module': 'cl_mod',
         'call_method': 'cl_meth',
@@ -136,5 +136,5 @@ def get_next_qparams_idx(module, qparams):
     for key, value in qparams.items():
         setattr(root_module, key + str(idx), value)
         qparam_full_path = key + str(idx)
-        inputs.append(graph.create_node('get_attr', qparam_full_path))
+        inputs.append(graph.create_node('get_param', qparam_full_path))
     return graph.create_node('call_function', quantize_op, tuple(inputs), {})