Add parameter checkers

Author: Peter Hamfelt

pylint_ml/checkers/sklearn/sklearn_parameter.py

@@ -0,0 +1,76 @@
+# Licensed under the MIT: https://mit-license.org/
+# For details: https://github.com/pylint-dev/pylint-ml/LICENSE
+# Copyright (c) https://github.com/pylint-dev/pylint-ml/CONTRIBUTORS.txt
+
+"""Check for proper usage of Tensorflow functions with required parameters."""
+
+from astroid import nodes
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import only_required_for_messages
+from pylint.interfaces import HIGH
+
+
+class TensorFlowParameterChecker(BaseChecker):
+    name = "tensor-parameter"
+    msgs = {
+        "W8111": (
+            "Ensure that required parameters %s are explicitly specified in TensorFlow method %s.",
+            "tensor-parameter",
+            "Explicitly specifying required parameters improves model performance and prevents unintended "
+            "behavior.",
+        ),
+    }
+
+    # Define required parameters for specific TensorFlow methods
+    REQUIRED_PARAMS = {
+        # Model Creation
+        'Sequential': ['layers'],  # Layers must be specified to build a model
+
+        # Model Compilation
+        'compile': ['optimizer', 'loss'],  # Optimizer and loss function are essential for training
+
+        # Model Training
+        'fit': ['x', 'y'],  # Input data (x) and target data (y) are required to train the model
+
+        # Layers
+        'Conv2D': ['filters', 'kernel_size'],  # Filters and kernel size define the convolutional layer's structure
+        'Dense': ['units'],  # Number of units (neurons) is crucial for a Dense layer
+    }
+
+    @only_required_for_messages("tensor-parameter")
+    def visit_call(self, node: nodes.Call) -> None:
+        if isinstance(node.func, nodes.Attribute):
+            method_name = node.func.attrname
+            if method_name in self.REQUIRED_PARAMS:
+                required_params = self.REQUIRED_PARAMS[method_name]
+                # Check for explicit parameters
+                missing_params = [param for param in required_params if
+                                  not any(kw.arg == param for kw in node.keywords)]
+
+                if missing_params:
+                    self.add_message(
+                        "tensor-parameter",
+                        node=node,
+                        confidence=HIGH,
+                        args=(', '.join(missing_params), method_name),
+                    )
+
+    @only_required_for_messages("tensor-parameter")
+    def visit_call(self, node: nodes.Call) -> None:
+        if isinstance(node.func, nodes.Attribute):
+            method_name = node.func.attrname
+            if method_name in self.REQUIRED_PARAMS:
+                required_params = self.REQUIRED_PARAMS[method_name]
+                # Extract all provided keyword arguments
+                provided_keywords = {kw.arg for kw in node.keywords if kw.arg is not None}
+
+                # Check if required parameters are provided explicitly as keyword arguments
+                missing_params = [param for param in required_params if param not in provided_keywords]
+
+                if missing_params:
+                    self.add_message(
+                        "tensor-parameter",
+                        node=node,
+                        confidence=HIGH,
+                        args=(', '.join(missing_params), method_name),
+                    )

pylint_ml/checkers/tensorflow/tensor_parameter.py

@@ -0,0 +1,53 @@
+# Licensed under the MIT: https://mit-license.org/
+# For details: https://github.com/pylint-dev/pylint-ml/LICENSE
+# Copyright (c) https://github.com/pylint-dev/pylint-ml/CONTRIBUTORS.txt
+
+"""Check for proper usage of PyTorch functions with required parameters."""
+
+from astroid import nodes
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import only_required_for_messages
+from pylint.interfaces import HIGH
+
+
+class PyTorchParameterChecker(BaseChecker):
+    name = "pytorch-parameter"
+    msgs = {
+        "W8111": (
+            "Ensure that required parameters %s are explicitly specified in PyTorch method %s.",
+            "pytorch-parameter",
+            "Explicitly specifying required parameters improves model performance and prevents unintended "
+            "behavior.",
+        ),
+    }
+
+    # Define required parameters for specific PyTorch methods
+    REQUIRED_PARAMS = {
+        # Optimizers
+        'SGD': ['lr'],  # Focus on the critical learning rate parameter
+        'Adam': ['lr'],  # Learning rate is typically the most important for tuning
+
+        # Layers
+        'Conv2d': ['in_channels', 'out_channels', 'kernel_size'],
+        # These parameters define the convolution's core operation
+        'Linear': ['in_features', 'out_features'],  # Essential to define the transformation dimensions
+        'LSTM': ['input_size', 'hidden_size'],  # Essential for defining the dimensionality of the LSTM cell
+    }
+
+    @only_required_for_messages("pytorch-parameter")
+    def visit_call(self, node: nodes.Call) -> None:
+        if isinstance(node.func, nodes.Attribute):
+            method_name = node.func.attrname
+            if method_name in self.REQUIRED_PARAMS:
+                required_params = self.REQUIRED_PARAMS[method_name]
+                # Check for explicit parameters
+                missing_params = [param for param in required_params if
+                                  not any(kw.arg == param for kw in node.keywords)]
+
+                if missing_params:
+                    self.add_message(
+                        "pytorch-parameter",
+                        node=node,
+                        confidence=HIGH,
+                        args=(', '.join(missing_params), method_name),
+                    )

pylint_ml/checkers/torch/torch_import.py

@@ -8,7 +8,7 @@
 from pylint_ml.checkers.scipy.scipy_import import ScipyImportChecker
 from pylint_ml.checkers.sklearn.sklearn_import import SklearnImportChecker
 from pylint_ml.checkers.tensorflow.tensorflow_import import TensorflowImportChecker
-from pylint_ml.checkers.torch.torch_import import TorchImportChecker
+from pylint_ml.checkers.torch.torch_parameter import PyTorchParameterChecker
 
 
 def register(linter: PyLinter) -> None:
@@ -24,7 +24,7 @@ def register(linter: PyLinter) -> None:
     linter.register_checker(TensorflowImportChecker(linter))
 
     # Torch
-    linter.register_checker(TorchImportChecker(linter))
+    linter.register_checker(PyTorchParameterChecker(linter))
 
     # Scipy
     linter.register_checker(ScipyImportChecker(linter))

pylint_ml/checkers/torch/torch_parameter.py

@@ -0,0 +1,187 @@
+import astroid
+import pylint.testutils
+from pylint.interfaces import HIGH
+
+from pylint_ml.checkers.tensorflow.tensor_parameter import TensorFlowParameterChecker
+
+
+class TestTensorParameterChecker(pylint.testutils.CheckerTestCase):
+    CHECKER_CLASS = TensorFlowParameterChecker
+
+    def test_sequential_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            model = tf.keras.models.Sequential()  # [tensor-parameter]
+            """
+        )
+
+        sequential_call = node.value
+
+        with self.assertAddsMessages(
+                pylint.testutils.MessageTest(
+                    msg_id="tensor-parameter",
+                    confidence=HIGH,
+                    node=sequential_call,
+                    args=("layers", "Sequential"),
+                ),
+                ignore_position=True,
+        ):
+            self.checker.visit_call(sequential_call)
+
+    def test_sequential_with_layers(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            model = tf.keras.Sequential(layers=[
+                tf.keras.layers.Dense(units=64, activation='relu'),
+                tf.keras.layers.Dense(units=10)
+            ])
+            """
+        )
+
+        sequential_call = node.value
+
+        with self.assertNoMessages():
+            self.checker.visit_call(sequential_call)
+
+    def test_compile_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            model = tf.keras.models.Sequential()
+            model.compile()  # [tensor-parameter]
+            """
+        )
+
+        with self.assertAddsMessages(
+                pylint.testutils.MessageTest(
+                    msg_id="tensor-parameter",
+                    confidence=HIGH,
+                    node=node,
+                    args=("optimizer, loss", "compile"),
+                ),
+                ignore_position=True,
+        ):
+            self.checker.visit_call(node)
+
+    def test_compile_with_all_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            model = tf.keras.models.Sequential()
+            model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])  # Should not trigger
+            """
+        )
+
+        compile_call = node
+
+        with self.assertNoMessages():
+            self.checker.visit_call(compile_call)
+
+    def test_fit_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            model = tf.keras.models.Sequential()
+            model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
+            model.fit(epochs=10)  # [tensor-parameter]
+            """
+        )
+
+        fit_call = node
+
+        with self.assertAddsMessages(
+                pylint.testutils.MessageTest(
+                    msg_id="tensor-parameter",
+                    confidence=HIGH,
+                    node=fit_call,
+                    args=("x, y", "fit"),
+                ),
+                ignore_position=True,
+        ):
+            self.checker.visit_call(fit_call)
+
+    def test_fit_with_all_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            model = tf.keras.models.Sequential()
+            model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
+            model.fit(x=train_data, y=train_labels, epochs=10)  # Should not trigger
+            """
+        )
+
+        fit_call = node
+
+        with self.assertNoMessages():
+            self.checker.visit_call(fit_call)
+
+    def test_conv2d_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            layer = tf.keras.layers.Conv2D(kernel_size=(3, 3))  # [tensor-parameter]
+            """
+        )
+
+        conv2d_call = node.value
+
+        with self.assertAddsMessages(
+                pylint.testutils.MessageTest(
+                    msg_id="tensor-parameter",
+                    confidence=HIGH,
+                    node=conv2d_call,
+                    args=("filters", "Conv2D"),
+                ),
+                ignore_position=True,
+        ):
+            self.checker.visit_call(conv2d_call)
+
+    def test_conv2d_with_all_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            layer = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3))  # Should not trigger
+            """
+        )
+
+        conv2d_call = node.value
+
+        with self.assertNoMessages():
+            self.checker.visit_call(conv2d_call)
+
+    def test_dense_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            layer = tf.keras.layers.Dense()  # [tensor-parameter]
+            """
+        )
+
+        dense_call = node.value
+
+        with self.assertAddsMessages(
+                pylint.testutils.MessageTest(
+                    msg_id="tensor-parameter",
+                    confidence=HIGH,
+                    node=dense_call,
+                    args=("units", "Dense"),
+                ),
+                ignore_position=True,
+        ):
+            self.checker.visit_call(dense_call)
+
+    def test_dense_with_all_params(self):
+        node = astroid.extract_node(
+            """
+            import tensorflow as tf
+            layer = tf.keras.layers.Dense(units=64)  # Should not trigger
+            """
+        )
+
+        dense_call = node.value
+
+        with self.assertNoMessages():
+            self.checker.visit_call(dense_call)
+