【Infer Symbolic Shape BUAA No13、66、91、122】Add 4 ops

paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/multiary_infer_sym.cc

@@ -613,6 +613,36 @@ bool BilinearInterpOpInferSymbolicShape(
   return BicubicInterpOpInferSymbolicShape(op, infer_context);
 }
 
+bool CheckFiniteAndUnscaleOpInferSymbolicShape(
+    pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
+  std::vector<symbol::ShapeOrDataDimExprs> xs_shapes;
+  for (size_t i = 0; i < op->num_operands() - 1; ++i) {
+    xs_shapes.push_back(
+        infer_context->GetShapeOrDataForValue(op->operand_source(i)));
+  }
+  // Ensure the number of inputs (xs) matches the number of outputs (outs)
+  infer_context->AddEqualCstr(
+      symbol::DimExpr(static_cast<int>(xs_shapes.size())),
+      symbol::DimExpr(static_cast<int>(op->num_results() - 1)));
+  for (size_t i = 0; i < xs_shapes.size(); ++i) {
+    symbol::TensorShapeOrDataDimExprs output_shape(xs_shapes[i].shape());
+    infer_context->SetShapeOrDataForValue(
+        op->result(i), symbol::ShapeOrDataDimExprs{output_shape});
+  }
+
+  symbol::TensorShapeOrDataDimExprs found_infinite_shape({symbol::DimExpr(1)});
+  infer_context->SetShapeOrDataForValue(
+      op->result(op->num_results() - 1),
+      symbol::ShapeOrDataDimExprs{found_infinite_shape});
+
+  return true;
+}
+
+bool CheckFiniteAndUnscale_OpInferSymbolicShape(
+    pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
+  return CheckFiniteAndUnscaleOpInferSymbolicShape(op, infer_context);
+}
+
 bool CrossEntropyWithSoftmaxOpInferSymbolicShape(
     pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
   const symbol::ShapeOrDataDimExprs &input_shape =
@@ -1102,6 +1132,48 @@ bool MeshgridOpInferSymbolicShape(
   return true;
 }
 
+bool MovingAverageAbsMaxScaleOpInferSymbolicShape(
+    pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
+  // Get the symbolic shape of the input tensor x
+  const symbol::ShapeOrDataDimExprs &x_shape =
+      infer_context->GetShapeOrDataForValue(op->operand_source(0));
+  // Get the symbolic shape of the input tensor in_state
+  const symbol::ShapeOrDataDimExprs &in_state_shape =
+      infer_context->GetShapeOrDataForValue(op->operand_source(2));
+  // Get the symbolic shape of the input tensor in_accum
+  const symbol::ShapeOrDataDimExprs &in_accum_shape =
+      infer_context->GetShapeOrDataForValue(op->operand_source(1));
+
+  // Set the shape for the output tensor out if it exists
+  if (op->num_results() > 0 && op->result(0) != nullptr) {
+    infer_context->SetShapeOrDataForValue(op->result(0), x_shape);
+  }
+
+  // Set the shape for the output tensor out_scale as a scalar if it exists
+  if (op->num_results() > 1 && op->result(1) != nullptr) {
+    symbol::TensorShapeOrDataDimExprs scalar_shape(
+        std::vector<symbol::DimExpr>{symbol::DimExpr(1)});
+    infer_context->SetShapeOrDataForValue(op->result(1), scalar_shape);
+  }
+
+  // Set the shape for the output tensor out_state if it exists
+  if (op->num_results() > 2 && op->result(2) != nullptr) {
+    infer_context->SetShapeOrDataForValue(op->result(2), in_state_shape);
+  }
+
+  // Set the shape for the output tensor out_accum if it exists
+  if (op->num_results() > 3 && op->result(3) != nullptr) {
+    infer_context->SetShapeOrDataForValue(op->result(3), in_accum_shape);
+  }
+
+  return true;
+}
+
+bool MovingAverageAbsMaxScale_OpInferSymbolicShape(
+    pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
+  return MovingAverageAbsMaxScaleOpInferSymbolicShape(op, infer_context);
+}
+
 bool StackOpInferSymbolicShape(pir::Operation *op,
                                pir::InferSymbolicShapeContext *infer_context) {
   pir::Value operand_source = op->operand_source(0);

paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/multiary_infer_sym.h

@@ -28,6 +28,8 @@ OP_DECLARE_INFER_SYMBOLIC_SHAPE(BatchNorm_)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(BicubicInterp)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Bilinear)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(BilinearInterp)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(CheckFiniteAndUnscale)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(CheckFiniteAndUnscale_)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Concat)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(CrossEntropyWithSoftmax)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(CrossEntropyWithSoftmax_)
@@ -42,6 +44,8 @@ OP_DECLARE_INFER_SYMBOLIC_SHAPE(LinearInterp)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Logspace)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(MemoryEfficientAttention)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Meshgrid)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(MovingAverageAbsMaxScale)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(MovingAverageAbsMaxScale_)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(NearestInterp)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(RoiAlign)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Stack)

paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/unary_infer_sym.cc

@@ -938,6 +938,22 @@ bool KthvalueOpInferSymbolicShape(
   return true;
 }
 
+bool L1NormOpInferSymbolicShape(pir::Operation *op,
+                                pir::InferSymbolicShapeContext *infer_context) {
+  // The output is a scalar, set the output shape accordingly
+  std::vector<symbol::DimExpr> output_shape;
+  infer_context->SetShapeOrDataForValue(
+      op->result(0),
+      symbol::ShapeOrDataDimExprs{
+          symbol::TensorShapeOrDataDimExprs(output_shape)});
+  return true;
+}
+
+bool L1Norm_OpInferSymbolicShape(
+    pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
+  return L1NormOpInferSymbolicShape(op, infer_context);
+}
+
 bool LpPool2dOpInferSymbolicShape(
     pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
   const auto &kernel_size = [&]() -> std::vector<symbol::DimExpr> {
@@ -1351,6 +1367,52 @@ bool ShapeOpInferSymbolicShape(pir::Operation *op,
   return true;
 }
 
+bool RreluOpInferSymbolicShape(pir::Operation *op,
+                               pir::InferSymbolicShapeContext *infer_context) {
+  float lower = op->attribute<pir::FloatAttribute>("lower").data();
+  float upper = op->attribute<pir::FloatAttribute>("upper").data();
+  const auto &x_shape_or_data =
+      infer_context->GetShapeOrDataForValue(op->operand_source(0));
+  const auto &x_shape = x_shape_or_data.shape();
+
+  // Check constraints for the attributes lower and upper
+  PADDLE_ENFORCE_GE(lower,
+                    0,
+                    phi::errors::InvalidArgument(
+                        "The lower value should be greater than or equal to 0. "
+                        "But received lower value = %f.",
+                        lower));
+  PADDLE_ENFORCE_LE(upper,
+                    1,
+                    phi::errors::InvalidArgument(
+                        "The upper value should be less than or equal to 1. "
+                        "But received upper value = %f.",
+                        upper));
+  PADDLE_ENFORCE_GE(
+      upper,
+      lower,
+      phi::errors::InvalidArgument(
+          "The upper value should be greater than or equal to lower value. "
+          "But received upper value = %f, lower value = %f.",
+          upper,
+          lower));
+
+  // Set the shape for the output tensor out
+  infer_context->SetShapeOrDataForValue(
+      op->result(0),
+      symbol::ShapeOrDataDimExprs{symbol::TensorShapeOrDataDimExprs(x_shape)});
+
+  // Set the shape for the output tensor noise if it exists
+  if (op->num_results() > 1 && op->result(1) != nullptr) {
+    infer_context->SetShapeOrDataForValue(
+        op->result(1),
+        symbol::ShapeOrDataDimExprs{
+            symbol::TensorShapeOrDataDimExprs(x_shape)});
+  }
+
+  return true;
+}
+
 bool ShapeSrOpInferSymbolicShape(
     pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
   return ShapeOpInferSymbolicShape(op, infer_context);

paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/unary_infer_sym.h

@@ -56,6 +56,8 @@ OP_DECLARE_INFER_SYMBOLIC_SHAPE(Flatten_)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(IdentityLoss)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(IdentityLoss_)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Kthvalue)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(L1Norm)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(L1Norm_)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(LpPool2d)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Logcumsumexp)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Logsumexp)
@@ -72,6 +74,7 @@ OP_DECLARE_INFER_SYMBOLIC_SHAPE(Prod)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(RepeatInterleave)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Reshape)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Reshape_)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(Rrelu)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Shape)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(ShapeSr)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Slice)

paddle/phi/ops/yaml/inconsistent/static_ops.yaml

@@ -960,6 +960,7 @@
     param: [x, in_accum, in_state, moving_rate, is_test]
   optional : in_accum, in_state, out, out_state, out_accum
   inplace : (in_accum -> out_accum), (in_state -> out_state)
+  interfaces : paddle::dialect::InferSymbolicShapeInterface
 
 - op: nce
   args: (Tensor input, Tensor label, Tensor weight, Tensor bias, Tensor sample_weight, Tensor custom_dist_probs, Tensor custom_dist_alias, Tensor custom_dist_alias_probs, int num_total_classes, int[] custom_neg_classes={}, int num_neg_samples=10, int sampler=0, int seed=0, bool is_sparse=false, bool remote_prefetch=false, bool is_test=false)

paddle/phi/ops/yaml/ops.yaml

@@ -846,6 +846,7 @@
     param : [x, scale]
     data_type : x
   inplace : (x -> out)
+  interfaces : paddle::dialect::InferSymbolicShapeInterface
 
 - op : check_numerics
   args : (Tensor tensor, str op_type = "", str var_name = "", int check_nan_inf_level = 0, int stack_height_limit = -1, str output_dir = "")
@@ -2623,6 +2624,7 @@
     data_type : x
   inplace: (x -> out)
   backward : l1_norm_grad
+  interfaces : paddle::dialect::InferSymbolicShapeInterface
 
 - op : label_smooth
   args : (Tensor label, Tensor prior_dist, float epsilon = 0.0f)
@@ -3921,6 +3923,7 @@
     data_type : x
   intermediate : noise
   backward : rrelu_grad
+  interfaces : paddle::dialect::InferSymbolicShapeInterface
 
 - op : rsqrt
   args : (Tensor x)