Merge pull request #77 from cleophass/GCI104-python

GCI104 AI AvoidCreatingTensorUsingNumpyOrNativePython #Python #DLG #Build

Author: dedece35

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- [#77](https://github.com/green-code-initiative/creedengo-python/pull/77) Add rule GCI104 AvoidCreatingTensorUsingNumpyOrNativePython, a rule specific to AI/ML code
 - [#70](https://github.com/green-code-initiative/creedengo-python/pull/70) Add rule GCI108 Prefer Append Left (a rule to prefer the use of `append` over `insert` for list, using deques)
 - [#78](https://github.com/green-code-initiative/creedengo-python/pull/78) Add rule GCI105 on String Concatenation. This rule may also apply to other rules
 - [#74](https://github.com/green-code-initiative/creedengo-python/pull/74) Add rule GCI101 Avoid Conv Bias Before Batch Normalization, a rule specific to Deeplearning

src/it/java/org/greencodeinitiative/creedengo/python/integration/tests/GCIRulesIT.java

@@ -366,6 +366,22 @@ void testGCI103(){
 
         checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_1MIN);  
     }
+
+    @Test
+    void testGCI104() {
+
+        String filePath = "src/avoidCreatingTensorUsingNumpyOrNativePython.py";
+        String ruleId = "creedengo-python:GCI104";
+        String ruleMsg = "Directly create tensors as torch.Tensor instead of using numpy functions.";
+        int[] startLines = new int[]{
+            5, 15, 19, 24
+        };
+        int[] endLines = new int[]{
+            5, 15, 19, 24
+        };
+
+        checkIssuesForFile(filePath, ruleId, ruleMsg, startLines, endLines, SEVERITY, TYPE, EFFORT_10MIN);
+    }
 
     @Test
     void testGCI105() {

src/it/test-projects/creedengo-python-plugin-test-project/src/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 instead of using numpy functions.}}
+
+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 instead of using numpy functions.}}
+    print(tensor_)
+
+def non_compliant_eye():
+    tensor = torch.cuda.LongTensor(np.eye(5)) # Noncompliant {{Directly create tensors as torch.Tensor instead of using numpy functions.}}
+
+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 instead of using numpy functions.}}

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

@@ -50,7 +50,8 @@ public class PythonRuleRepository implements RulesDefinition, PythonCustomRuleRe
             AvoidNonPinnedMemoryForDataloaders.class,
             AvoidConvBiasBeforeBatchNorm.class,
             StringConcatenation.class,
-            PreferAppendLeft.class
+            PreferAppendLeft.class,
+            AvoidCreatingTensorUsingNumpyOrNativePython.class
     );
 
     public static final String LANGUAGE = "py";

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

@@ -0,0 +1,86 @@
+/*
+ * 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.greencodeinitiative.creedengo.python.utils.UtilsAST;
+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 {
+
+  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 instead of using numpy functions.";
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> {
+      CallExpression callExpression = (CallExpression) ctx.syntaxNode();
+      if (torchTensorConstructors.contains(UtilsAST.getQualifiedName(callExpression))) {
+        RegularArgument tensorCreatorArgument = UtilsAST.nthArgumentOrKeyword(dataArgumentPosition, dataArgumentName, callExpression.arguments());
+        if (tensorCreatorArgument != null) {
+          if (tensorCreatorArgument.expression().is(CALL_EXPR)) {
+            String functionQualifiedName = UtilsAST.getQualifiedName((CallExpression) tensorCreatorArgument.expression());
+            if (torchOtherFunctionsMapping.containsKey(functionQualifiedName)) {
+              ctx.addIssue(callExpression, MESSAGE);
+            }
+          }
+        }
+      }
+    });
+  }
+}

src/main/java/org/greencodeinitiative/creedengo/python/utils/UtilsAST.java

@@ -52,6 +52,19 @@ public static String getQualifiedName(CallExpression callExpression) {
                 .orElse("");
     }
 
+    /**
+     * Retrieves the variable name from the given SubscriptionContext.
+     *
+     * This method traverses the syntax tree of the provided context to locate
+     * the nearest assignment statement. If an assignment statement is found,
+     * it extracts the name of the variable on the left-hand side of the assignment.
+     *
+     * @param context The SubscriptionContext containing the syntax node to analyze.
+     *                It may be null or contain a null syntax node, in which case
+     *                the method returns null.
+     * @return The name of the variable on the left-hand side of the assignment
+     *         statement, or null if no valid variable name can be determined.
+     */
     public static String getVariableName(SubscriptionContext context) {
 
         if (context == null || context.syntaxNode() == null) {

src/main/resources/org/greencodeinitiative/creedengo/python/creedengo_way_profile.json

@@ -16,6 +16,7 @@
 		"GCI101",
 		"GCI102",
 		"GCI103",
+		"GCI104",
 		"GCI105",
 		"GCI106",
 		"GCI107",

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 instead of using numpy functions.}}
+
+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 instead of using numpy functions.}}
+    print(tensor_)
+
+def non_compliant_eye():
+    tensor = torch.cuda.LongTensor(np.eye(5)) # Noncompliant {{Directly create tensors as torch.Tensor instead of using numpy functions.}}
+
+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 instead of using numpy functions.}}