[PIR] Replace OpResult with Value in python

python/paddle/autograd/backward_utils.py

@@ -172,13 +172,13 @@ class State:
 
     def __init__(self, block):
         self.block = block
-        # opresult -> list(list(opresult))
+        # value -> list(list(value))
         self.value_to_valuegrad = ValueDict(default_factory=list)
         self.value_to_sumvaluegrad = ValueDict(default_factory=list)
         # operation -> list(operation)
         self.op_to_opgrad = collections.defaultdict(list)
 
-        # opresult -> list(opresult)
+        # value -> list(value)
         self.valuegrad_to_value = ValueDict(default_factory=list)
         self.sumvaluegrad_to_value = ValueDict(default_factory=list)
         # operation -> list(operation)
@@ -213,7 +213,7 @@ def copy(self, new_block):
         # operation -> list(operation)
         state.op_to_opgrad = self.op_to_opgrad.copy()
 
-        # opresult -> list(opresult)
+        # value -> list(value)
         state.valuegrad_to_value = self.valuegrad_to_value.copy()
         state.sumvaluegrad_to_value = self.sumvaluegrad_to_value.copy()
         # operation -> list(operation)

python/paddle/autograd/ir_backward.py

@@ -1202,27 +1202,27 @@ def grad(
     check_type(
         outputs,
         'outputs',
-        ((paddle.pir.Value, paddle.pir.OpResult), list, tuple),
+        (paddle.pir.Value, list, tuple),
         'paddle.autograd.ir_backward.grad',
     )
     check_type(
         inputs,
         'inputs',
-        ((paddle.pir.Value, paddle.pir.OpResult), list, tuple),
+        (paddle.pir.Value, list, tuple),
         'paddle.autograd.ir_backward.grad',
     )
     check_type(
         grad_outputs,
         'grad_outputs',
-        ((paddle.pir.Value, paddle.pir.OpResult), list, tuple, type(None)),
+        (paddle.pir.Value, list, tuple, type(None)),
         'paddle.autograd.ir_backward.grad',
     )
 
     check_type(
         no_grad_vars,
         'no_grad_vars',
         (
-            (paddle.pir.Value, paddle.pir.OpResult),
+            paddle.pir.Value,
             list,
             tuple,
             set,
@@ -1265,7 +1265,7 @@ def append_backward(loss, parameter_list=None, no_grad_set=None):
     check_type(
         loss,
         'loss',
-        (paddle.pir.Value, paddle.pir.OpResult),
+        paddle.pir.Value,
         'paddle.autograd.ir_backward.append_backward',
     )
 
@@ -1280,7 +1280,7 @@ def append_backward(loss, parameter_list=None, no_grad_set=None):
             check_type(
                 param,
                 'parameter_list[%s]' % i,
-                (paddle.pir.Value, paddle.pir.OpResult),
+                paddle.pir.Value,
                 'base.backward.append_backward',
             )
 

python/paddle/base/backward.py

@@ -2752,27 +2752,27 @@ def gradients(targets, inputs, target_gradients=None, no_grad_set=None):
         check_type(
             targets,
             'targets',
-            ((paddle.pir.Value, paddle.pir.OpResult), list, tuple),
+            (paddle.pir.Value, list, tuple),
             'paddle.autograd.ir_backward.grad',
         )
         check_type(
             inputs,
             'inputs',
-            ((paddle.pir.Value, paddle.pir.OpResult), list, tuple),
+            (paddle.pir.Value, list, tuple),
             'paddle.autograd.ir_backward.grad',
         )
         check_type(
             target_gradients,
             'target_gradients',
-            ((paddle.pir.Value, paddle.pir.OpResult), list, tuple, type(None)),
+            (paddle.pir.Value, list, tuple, type(None)),
             'paddle.autograd.ir_backward.grad',
         )
 
         check_type(
             no_grad_set,
             'no_grad_set',
             (
-                (paddle.pir.Value, paddle.pir.OpResult),
+                paddle.pir.Value,
                 list,
                 tuple,
                 set,

python/paddle/base/layer_helper_base.py

@@ -97,9 +97,7 @@ def to_variable(self, value, name=None):
                 name if name else None,
                 True,
             )
-        elif isinstance(
-            value, (Variable, core.eager.Tensor, paddle.pir.OpResult)
-        ):
+        elif isinstance(value, (Variable, core.eager.Tensor, paddle.pir.Value)):
             return value
         else:
             raise TypeError(

python/paddle/base/variable_index.py

@@ -234,17 +234,11 @@ def slice_is_same_to_original(start, end, step):
         return True
 
     # If there is Variable, we cannot determine whether it is the same to original.
-    if isinstance(
-        start, (paddle.base.Variable, paddle.pir.Value, paddle.pir.OpResult)
-    ):
+    if isinstance(start, (paddle.base.Variable, paddle.pir.Value)):
         return False
-    if isinstance(
-        end, (paddle.base.Variable, paddle.pir.Value, paddle.pir.OpResult)
-    ):
+    if isinstance(end, (paddle.base.Variable, paddle.pir.Value)):
         return False
-    if isinstance(
-        step, (paddle.base.Variable, paddle.pir.Value, paddle.pir.OpResult)
-    ):
+    if isinstance(step, (paddle.base.Variable, paddle.pir.Value)):
         return False
     return start == 0 and end == MAX_INTEGER and step == 1
 
@@ -594,9 +588,7 @@ def _setitem_static(x, indices, values):
         #   3. assign values to the sliced result by index_put OP;
         #   4. transpose back and assign the result to original tensor by set_value OP.
 
-        if not isinstance(
-            values, (Variable, paddle.pir.Value, paddle.pir.OpResult)
-        ):
+        if not isinstance(values, (Variable, paddle.pir.Value)):
             values = paddle.assign(values).astype(x.dtype)
 
         sub_tensor = get_tensor_with_basic_indexing(

python/paddle/decomposition/decomp.py

@@ -884,7 +884,7 @@ def _reset_prim_state(state):
 
 
 def _translate_gradvartovar_to_pir(param_mapping, grad_var_to_var):
-    '''translate grad_var_to_var (mapping VarDesc->VarDesc) to pir_grad_var_to_var (mapping OpResult->OpResult)'''
+    '''translate grad_var_to_var (mapping VarDesc->VarDesc) to pir_grad_var_to_var (mapping Value->Value)'''
     pir_grad_var_to_var = ValueDict()
     for grad_var, var in grad_var_to_var.items():
         if grad_var in param_mapping.keys() and var in param_mapping.keys():
@@ -992,7 +992,7 @@ def decompose_pir_program(pir_program, param_mapping, grad_var_to_var):
     Decompose all PHI ops into prim ops in a pir program.
     Args:
         pir_program (Program): the program to be decomposed
-        param_mapping (dict): a map of program variables to pir program opresults
+        param_mapping (dict): a map of program variables to pir program values
         grad_var_to_var (dict): a dict obtained from distributed processing,
             which maps the backward grad variable to its corresponding forward variable.
     '''

python/paddle/jit/pir_dy2static/parameter_recorder.py

@@ -21,7 +21,7 @@
 class ParametersRecorder:
     def __init__(self):
         self.params_dict = {}
-        self.tensor2opresult = {}
+        self.tensor2value = {}
 
     @synchronized
     def get(self, program, tensor):
@@ -31,10 +31,10 @@ def get(self, program, tensor):
         key = _program_hash(program)
         if key not in self.params_dict:
             self.params_dict[key] = set()
-            self.tensor2opresult[key] = {}
+            self.tensor2value[key] = {}
 
         params = self.params_dict[key]
-        mappings = self.tensor2opresult[key]
+        mappings = self.tensor2value[key]
         if id(tensor) not in mappings:
             non_used_initializer = paddle.nn.initializer.Constant(0.0)
             op_result = create_parameter(
@@ -54,10 +54,10 @@ def pop(self, program):
         if params is None:
             return [], []
         params_values = [
-            self.tensor2opresult[hash_id][id(x)] for x in list(params)
+            self.tensor2value[hash_id][id(x)] for x in list(params)
         ]
         del self.params_dict[hash_id]
-        del self.tensor2opresult[hash_id]
+        del self.tensor2value[hash_id]
         return list(params), list(params_values)
 
 

python/paddle/optimizer/adamw.py

@@ -19,7 +19,7 @@
 import paddle
 from paddle import pir
 from paddle.base.libpaddle import DataType
-from paddle.pir import OpResult
+from paddle.pir import Value
 
 from .. import _C_ops
 from ..base import core, framework
@@ -182,7 +182,7 @@ def __init__(
         if not 0 <= epsilon:
             raise ValueError("Invaild value of epsilon, expect epsilon >= 0.")
         if not isinstance(weight_decay, float) and not isinstance(
-            weight_decay, (framework.Variable, OpResult)
+            weight_decay, (framework.Variable, Value)
         ):
             raise TypeError("weight_decay should be float or Tensor.")
         if lr_ratio is not None:
@@ -375,7 +375,7 @@ def _add_moments_pows(self, p):
             param=p,
             dtype=acc_dtype,
             fill_value=0.9
-            if isinstance(self._beta1, (Variable, OpResult))
+            if isinstance(self._beta1, (Variable, Value))
             else self._beta1,
             shape=[1],
             type=core.VarDesc.VarType.LOD_TENSOR,
@@ -386,7 +386,7 @@ def _add_moments_pows(self, p):
             param=p,
             dtype=acc_dtype,
             fill_value=0.999
-            if isinstance(self._beta2, (Variable, OpResult))
+            if isinstance(self._beta2, (Variable, Value))
             else self._beta2,
             shape=[1],
             type=core.VarDesc.VarType.LOD_TENSOR,

python/paddle/optimizer/momentum.py

@@ -476,12 +476,12 @@ def _append_optimize_multi_tensor_op(
                     found_inf = self._get_auxiliary_var('found_inf')
                     if found_inf:
                         if isinstance(
-                            found_inf, (core.eager.Tensor, paddle.pir.OpResult)
+                            found_inf, (core.eager.Tensor, paddle.pir.Value)
                         ):
                             self._set_auxiliary_var('found_inf', True)
                     else:
                         if isinstance(
-                            found_inf, (core.eager.Tensor, paddle.pir.OpResult)
+                            found_inf, (core.eager.Tensor, paddle.pir.Value)
                         ):
                             self._set_auxiliary_var('found_inf', False)
                         _, _, _ = _C_ops.merged_momentum_(

python/paddle/optimizer/optimizer.py

@@ -457,7 +457,7 @@ def do_create():
                         set_parameter(init_result, lr_name)
                     main_program.move_parameters_from(startup_program)
 
-                    if not isinstance(lr_var, paddle.pir.OpResult):
+                    if not isinstance(lr_var, paddle.pir.Value):
                         self._learning_rate._var_name = lr_name
                         with paddle.static.program_guard(main_program):
                             param = parameter(lr_name, _lr_dtype, [])
@@ -497,7 +497,7 @@ def do_create():
                 # only create global lr_var once
                 lr = self._global_learning_rate()
                 if in_pir_mode():
-                    if isinstance(lr, paddle.pir.OpResult):
+                    if isinstance(lr, paddle.pir.Value):
                         return
                     else:
                         place = _current_expected_place()
@@ -764,7 +764,7 @@ def _create_param_lr(self, param_and_grad):
         param = param_and_grad[0]
         if hasattr(param, 'optimize_attr'):
             param_lr = param.optimize_attr['learning_rate']
-            if isinstance(param_lr, (Variable, paddle.pir.OpResult)):
+            if isinstance(param_lr, (Variable, paddle.pir.Value)):
                 return param_lr
             else:
                 if param_lr == 1.0:
@@ -1735,7 +1735,7 @@ def minimize(
 
         """
         assert isinstance(
-            loss, (Variable, paddle.pir.OpResult)
+            loss, (Variable, paddle.pir.Value)
         ), "The loss should be an Tensor."
 
         parameter_list = parameters if parameters else self._parameter_list

python/paddle/pir/__init__.py

@@ -16,7 +16,6 @@
     Block,
     Operation,
     OpOperand,
-    OpResult,
     PassManager,
     Program,
     Type,

python/paddle/pir/core.py

@@ -332,7 +332,7 @@ def create_parameter(
 
 def _convert_into_value(tensor):
     """
-    Convert Tensor into OpResult.
+    Convert Tensor into Value.
     """
     import paddle
     from paddle.jit.pir_dy2static.parameter_recorder import (

python/paddle/regularizer.py

@@ -124,7 +124,7 @@ def __call__(self, param, grad, block):
             new variable for weight decay
         """
         assert isinstance(
-            param, (framework.Variable, pir.OpResult, pir.core.ParameterMeta)
+            param, (framework.Variable, pir.Value, pir.core.ParameterMeta)
         )
         assert isinstance(block, (framework.Block, pir.Block))
 
@@ -236,7 +236,7 @@ def __call__(self, param, grad, block):
             new variable for weight decay
         """
         assert isinstance(
-            param, (framework.Variable, pir.OpResult, pir.core.ParameterMeta)
+            param, (framework.Variable, pir.Value, pir.core.ParameterMeta)
         )
         assert isinstance(block, (framework.Block, pir.Block))
 

python/paddle/tensor/attribute.py

@@ -238,7 +238,7 @@ def is_integer(x):
             True
     """
     if not isinstance(
-        x, (paddle.Tensor, paddle.static.Variable, paddle.pir.OpResult)
+        x, (paddle.Tensor, paddle.static.Variable, paddle.pir.Value)
     ):
         raise TypeError(f"Expected Tensor, but received type of x: {type(x)}")
     dtype = x.dtype