GCI104 AI AvoidCreatingTensorUsingNumpyOrNativePython #Python #DLG #Build

Co-authored-by: DataLabGroupe-CreditAgricole <[email protected]>

Author: cleophass

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Add rule GCI 104 AvoidCreatingTensorUsingNumpyOrNativePython, a rule specific to AI/ML code
+
 ### Changed
 
 - compatibility updates for SonarQube 25.5.0

src/main/java/org/greencodeinitiative/creedengo/python/PythonRuleRepository.java

@@ -40,7 +40,8 @@ public class PythonRuleRepository implements RulesDefinition, PythonCustomRuleRe
             AvoidFullSQLRequest.class,
             AvoidListComprehensionInIterations.class,
             DetectUnoptimizedImageFormat.class,
-            AvoidMultipleIfElseStatementCheck.class
+            AvoidMultipleIfElseStatementCheck.class,
+            AvoidCreatingTensorUsingNumpyOrNativePython.class
     );
 
     public static final String LANGUAGE = "py";

src/main/java/org/greencodeinitiative/creedengo/python/checks/AvoidCreatingTensorUsingNumpyOrNativePython.java

@@ -0,0 +1,87 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+import org.sonar.check.Priority;
+import org.sonar.check.Rule;
+import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.RegularArgument;
+
+import java.util.List;
+import java.util.Map;
+
+import static java.util.Map.entry;
+import static org.sonar.plugins.python.api.tree.Tree.Kind.CALL_EXPR;
+
+@Rule(key = "GCI104")
+public class AvoidCreatingTensorUsingNumpyOrNativePython extends PythonSubscriptionCheck {
+
+  public static final String RULE_KEY = "P5";
+  private static final String dataArgumentName = "data";
+  private static final int dataArgumentPosition = 0;
+  private static final Map<String, String> torchOtherFunctionsMapping = Map.ofEntries(
+    entry("numpy.random.rand", "torch.rand"),
+    entry("numpy.random.randint", "torch.randint"),
+    entry("numpy.random.randn", "torch.randn"),
+    entry("numpy.zeros", "torch.zeros"),
+    entry("numpy.zeros_like", "torch.zeros_like"),
+    entry("numpy.ones", "torch.ones"),
+    entry("numpy.ones_like", "torch.ones_like"),
+    entry("numpy.full", "torch.full"),
+    entry("numpy.full_like", "torch.full_like"),
+    entry("numpy.eye", "torch.eye"),
+    entry("numpy.arange", "torch.arange"),
+    entry("numpy.linspace", "torch.linspace"),
+    entry("numpy.logspace", "torch.logspace"),
+    entry("numpy.identity", "torch.eye"),
+    entry("numpy.tile", "torch.tile")
+  );
+  private static final List<String> torchTensorConstructors = List.of(
+    "torch.tensor", "torch.FloatTensor",
+    "torch.DoubleTensor", "torch.HalfTensor",
+    "torch.BFloat16Tensor", "torch.ByteTensor",
+    "torch.CharTensor", "torch.ShortTensor",
+    "torch.IntTensor", "torch.LongTensor",
+    "torch.BoolTensor", "torch.cuda.FloatTensor",
+    "torch.cuda.DoubleTensor", "torch.cuda.HalfTensor",
+    "torch.cuda.BFloat16Tensor", "torch.cuda.ByteTensor",
+    "torch.cuda.CharTensor", "torch.cuda.ShortTensor",
+    "torch.cuda.IntTensor", "torch.cuda.LongTensor",
+    "torch.cuda.BoolTensor");
+  protected static final String MESSAGE = "Directly create tensors as torch.Tensor. Use %s instead of %s.";
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> {
+      CallExpression callExpression = (CallExpression) ctx.syntaxNode();
+      if (torchTensorConstructors.contains(Utils.getQualifiedName(callExpression))) {
+        RegularArgument tensorCreatorArgument = Utils.nthArgumentOrKeyword(dataArgumentPosition, dataArgumentName, callExpression.arguments());
+        if (tensorCreatorArgument != null) {
+          if (tensorCreatorArgument.expression().is(CALL_EXPR)) {
+            String functionQualifiedName = Utils.getQualifiedName((CallExpression) tensorCreatorArgument.expression());
+            if (torchOtherFunctionsMapping.containsKey(functionQualifiedName)) {
+              ctx.addIssue(callExpression, String.format(MESSAGE, torchOtherFunctionsMapping.get(functionQualifiedName), functionQualifiedName));
+            }
+          }
+        }
+      }
+    });
+  }
+}

src/main/java/org/greencodeinitiative/creedengo/python/checks/Utils.java

@@ -0,0 +1,102 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.Argument;
+import org.sonar.plugins.python.api.tree.AssignmentStatement;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.Expression;
+
+import javax.annotation.CheckForNull;
+import java.util.List;
+import java.util.Objects;
+
+public class Utils {
+
+  private static boolean hasKeyword(Argument argument, String keyword) {
+    if (!argument.is(new Tree.Kind[] {Tree.Kind.REGULAR_ARGUMENT})) {
+      return false;
+    } else {
+      Name keywordArgument = ((RegularArgument) argument).keywordArgument();
+      return keywordArgument != null && keywordArgument.name().equals(keyword);
+    }
+  }
+
+  @CheckForNull
+  public static RegularArgument nthArgumentOrKeyword(int argPosition, String keyword, List<Argument> arguments) {
+    for (int i = 0; i < arguments.size(); ++i) {
+      Argument argument = (Argument) arguments.get(i);
+      if (hasKeyword(argument, keyword)) {
+        return (RegularArgument) argument;
+      }
+
+      if (argument.is(new Tree.Kind[] {Tree.Kind.REGULAR_ARGUMENT})) {
+        RegularArgument regularArgument = (RegularArgument) argument;
+        if (regularArgument.keywordArgument() == null && argPosition == i) {
+          return regularArgument;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  public static String getQualifiedName(CallExpression callExpression) {
+    Symbol symbol = callExpression.calleeSymbol();
+
+    return symbol != null && symbol.fullyQualifiedName() != null ? symbol.fullyQualifiedName() : "";
+  }
+
+  public static String getMethodName(CallExpression callExpression) {
+    Symbol symbol = callExpression.calleeSymbol();
+    return symbol != null && symbol.name() != null ? symbol.name() : "";
+  }
+
+  public static List<Argument> getArgumentsFromCall(CallExpression callExpression) {
+    try {
+      return Objects.requireNonNull(callExpression.argumentList()).arguments();
+    } catch (NullPointerException e) {
+      return List.of();
+    }
+  }
+
+  public static String getVariableName(SubscriptionContext context) {
+    Tree node = context.syntaxNode();
+    Tree current = node;
+    while (current != null && !current.is(Tree.Kind.ASSIGNMENT_STMT)) {
+        current = current.parent();
+    }
+    if (current != null && current.is(Tree.Kind.ASSIGNMENT_STMT)) {
+      AssignmentStatement assignment = (AssignmentStatement) current;
+      if (!assignment.lhsExpressions().isEmpty() && !assignment.lhsExpressions().get(0).expressions().isEmpty()) {
+              Expression leftExpr = assignment.lhsExpressions().get(0).expressions().get(0);
+              if (leftExpr.is(Tree.Kind.NAME)) {
+                  Name variableName = (Name) leftExpr;
+                  return variableName.name();
+              }
+          }
+      
+    }
+    return null;
+  }
+}

src/test/java/org/greencodeinitiative/creedengo/python/checks/AvoidCreatingTensorUsingNumpyOrNativePythonTest.java

@@ -0,0 +1,31 @@
+/*
+ * creedengo - Python language - Provides rules to reduce the environmental footprint of your Python programs
+ * Copyright © 2024 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.python.checks;
+
+import org.junit.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+
+
+public class AvoidCreatingTensorUsingNumpyOrNativePythonTest {
+    @Test
+    public void test() {
+      PythonCheckVerifier.verify("src/test/resources/checks/avoidCreatingTensorUsingNumpyOrNativePython.py", new AvoidCreatingTensorUsingNumpyOrNativePython());
+    }
+    
+}

src/test/resources/checks/avoidCreatingTensorUsingNumpyOrNativePython.py

@@ -0,0 +1,24 @@
+import numpy as np
+import torch
+
+def non_compliant_random_rand():
+    tensor = torch.tensor(np.random.rand(1000, 1000)) # Noncompliant {{Directly create tensors as torch.Tensor. Use torch.rand instead of numpy.random.rand.}}
+
+def compliant_random_rand():
+    tensor = torch.rand([1000, 1000])
+
+def compliant_zeros():
+    tensor_ = torch.zeros(1, 2)
+    print(tensor_)
+
+def non_compliant_zeros():
+    tensor_ = torch.IntTensor(np.zeros(1, 2)) # Noncompliant {{Directly create tensors as torch.Tensor. Use torch.zeros instead of numpy.zeros.}}
+    print(tensor_)
+
+def non_compliant_eye():
+    tensor = torch.cuda.LongTensor(np.eye(5)) # Noncompliant {{Directly create tensors as torch.Tensor. Use torch.eye instead of numpy.eye.}}
+
+def non_compliant_ones():
+    import numpy
+    from torch import FloatTensor
+    tensor = FloatTensor(data=np.ones(shape=(1, 5))) # Noncompliant {{Directly create tensors as torch.Tensor. Use torch.ones instead of numpy.ones.}}