Fix more flake errors

Signed-off-by: Gaurav Gupta <gaugup@microsoft.com>

Author: gaugup

tests/test_dice_interface/test_dice_KD.py

@@ -47,7 +47,7 @@ def _initiate_exp_object(self, KD_binary_classification_exp_object):
         self.data_df_copy = self.exp.data_interface.data_df.copy()
 
     # When a query's feature value is not within the permitted range and the feature is not allowed to vary
-    @pytest.mark.parametrize("desired_range, desired_class, total_CFs, features_to_vary, permitted_range",
+    @pytest.mark.parametrize(("desired_range", "desired_class", "total_CFs", "features_to_vary", "permitted_range"),
                              [(None, 0, 4, ['Numerical'], {'Categorical': ['b', 'c']})])
     def test_invalid_query_instance(self, desired_range, desired_class, sample_custom_query_1, total_CFs,
                                     features_to_vary, permitted_range):
@@ -59,20 +59,20 @@ def test_invalid_query_instance(self, desired_range, desired_class, sample_custo
                                                features_to_vary=features_to_vary, permitted_range=permitted_range)
 
     # Verifying the output of the KD tree
-    @pytest.mark.parametrize("desired_class, total_CFs", [(0, 1)])
-    @pytest.mark.parametrize('posthoc_sparsity_algorithm', ['linear', 'binary', None])
+    @pytest.mark.parametrize(("desired_class", "total_CFs"), [(0, 1)])
+    @pytest.mark.parametrize(("posthoc_sparsity_algorithm"), ['linear', 'binary', None])
     def test_KD_tree_output(self, desired_class, sample_custom_query_1, total_CFs, posthoc_sparsity_algorithm):
         self.exp._generate_counterfactuals(query_instance=sample_custom_query_1, desired_class=desired_class,
                                            total_CFs=total_CFs,
                                            posthoc_sparsity_algorithm=posthoc_sparsity_algorithm)
         self.exp.final_cfs_df.Numerical = self.exp.final_cfs_df.Numerical.astype(int)
         expected_output = self.exp.data_interface.data_df
 
-        assert all(self.exp.final_cfs_df.Numerical == expected_output.Numerical[0]) and \
-               all(self.exp.final_cfs_df.Categorical == expected_output.Categorical[0])
+        assert all(self.exp.final_cfs_df.Numerical == expected_output.Numerical[0])
+        assert all(self.exp.final_cfs_df.Categorical == expected_output.Categorical[0])
 
     # Verifying the output of the KD tree
-    @pytest.mark.parametrize("desired_class, total_CFs", [(0, 1)])
+    @pytest.mark.parametrize(("desired_class", "total_CFs"), [(0, 1)])
     def test_KD_tree_counterfactual_explanations_output(self, desired_class, sample_custom_query_1, total_CFs):
         counterfactual_explanations = self.exp.generate_counterfactuals(
             query_instances=sample_custom_query_1, desired_class=desired_class,
@@ -81,35 +81,35 @@ def test_KD_tree_counterfactual_explanations_output(self, desired_class, sample_
         assert counterfactual_explanations is not None
 
     # Testing that the features_to_vary argument actually varies only the features that you wish to vary
-    @pytest.mark.parametrize("desired_class, total_CFs, features_to_vary", [(0, 1, ["Numerical"])])
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "features_to_vary"), [(0, 1, ["Numerical"])])
     def test_features_to_vary(self, desired_class, sample_custom_query_2, total_CFs, features_to_vary):
         self.exp._generate_counterfactuals(query_instance=sample_custom_query_2, desired_class=desired_class,
                                            total_CFs=total_CFs, features_to_vary=features_to_vary)
         self.exp.final_cfs_df.Numerical = self.exp.final_cfs_df.Numerical.astype(int)
         expected_output = self.exp.data_interface.data_df
 
-        assert all(self.exp.final_cfs_df.Numerical == expected_output.Numerical[1]) and \
-               all(self.exp.final_cfs_df.Categorical == expected_output.Categorical[1])
+        assert all(self.exp.final_cfs_df.Numerical == expected_output.Numerical[1])
+        assert all(self.exp.final_cfs_df.Categorical == expected_output.Categorical[1])
 
     # Testing that the permitted_range argument actually varies the features only within the permitted_range
-    @pytest.mark.parametrize("desired_class, total_CFs, permitted_range", [(0, 1, {'Numerical': [1000, 10000]})])
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "permitted_range"), [(0, 1, {'Numerical': [1000, 10000]})])
     def test_permitted_range(self, desired_class, sample_custom_query_2, total_CFs, permitted_range):
         self.exp._generate_counterfactuals(query_instance=sample_custom_query_2, desired_class=desired_class,
                                            total_CFs=total_CFs, permitted_range=permitted_range)
         self.exp.final_cfs_df.Numerical = self.exp.final_cfs_df.Numerical.astype(int)
         expected_output = self.exp.data_interface.data_df
-        assert all(self.exp.final_cfs_df.Numerical == expected_output.Numerical[1]) and \
-               all(self.exp.final_cfs_df.Categorical == expected_output.Categorical[1])
+        assert all(self.exp.final_cfs_df.Numerical == expected_output.Numerical[1])
+        assert all(self.exp.final_cfs_df.Categorical == expected_output.Categorical[1])
 
     # Testing if you can provide permitted_range for categorical variables
-    @pytest.mark.parametrize("desired_class, total_CFs, permitted_range", [(0, 4, {'Categorical': ['b', 'c']})])
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "permitted_range"), [(0, 4, {'Categorical': ['b', 'c']})])
     def test_permitted_range_categorical(self, desired_class, sample_custom_query_2, total_CFs, permitted_range):
         self.exp._generate_counterfactuals(query_instance=sample_custom_query_2, desired_class=desired_class,
                                            total_CFs=total_CFs, permitted_range=permitted_range)
         assert all(i in permitted_range["Categorical"] for i in self.exp.final_cfs_df.Categorical.values)
 
     # Ensuring that there are no duplicates in the resulting counterfactuals even if the dataset has duplicates
-    @pytest.mark.parametrize("desired_class, total_CFs", [(0, 2)])
+    @pytest.mark.parametrize(("desired_class", "total_CFs"), [(0, 2)])
     def test_duplicates(self, desired_class, sample_custom_query_4, total_CFs):
         self.exp._generate_counterfactuals(query_instance=sample_custom_query_4, total_CFs=total_CFs,
                                            desired_class=desired_class)
@@ -123,8 +123,8 @@ def test_duplicates(self, desired_class, sample_custom_query_4, total_CFs):
         assert all(self.exp.final_cfs_df == expected_output)
 
     # Testing for index returned
-    @pytest.mark.parametrize("desired_class, total_CFs", [(0, 1)])
-    @pytest.mark.parametrize('posthoc_sparsity_algorithm', ['linear', 'binary', None])
+    @pytest.mark.parametrize(("desired_class", "total_CFs"), [(0, 1)])
+    @pytest.mark.parametrize(("posthoc_sparsity_algorithm"), ['linear', 'binary', None])
     def test_index(self, desired_class, sample_custom_query_index, total_CFs, posthoc_sparsity_algorithm):
         self.exp._generate_counterfactuals(query_instance=sample_custom_query_index, total_CFs=total_CFs,
                                            desired_class=desired_class,
@@ -139,8 +139,8 @@ def _initiate_exp_object(self, KD_multi_classification_exp_object):
         self.data_df_copy = self.exp_multi.data_interface.data_df.copy()
 
     # Testing that the output of multiclass classification lies in the desired_class
-    @pytest.mark.parametrize("desired_class, total_CFs", [(2, 3)])
-    @pytest.mark.parametrize('posthoc_sparsity_algorithm', ['linear', 'binary', None])
+    @pytest.mark.parametrize(("desired_class", "total_CFs"), [(2, 3)])
+    @pytest.mark.parametrize(("posthoc_sparsity_algorithm"), ['linear', 'binary', None])
     def test_KD_tree_output(self, desired_class, sample_custom_query_2, total_CFs,
                             posthoc_sparsity_algorithm):
         self.exp_multi._generate_counterfactuals(query_instance=sample_custom_query_2, total_CFs=total_CFs,
@@ -156,9 +156,9 @@ def _initiate_exp_object(self, KD_regression_exp_object):
         self.data_df_copy = self.exp_regr.data_interface.data_df.copy()
 
     # Testing that the output of regression lies in the desired_range
-    @pytest.mark.parametrize("desired_range, total_CFs", [([1, 2.8], 6)])
-    @pytest.mark.parametrize("version", ['2.0', '1.0'])
-    @pytest.mark.parametrize('posthoc_sparsity_algorithm', ['linear', 'binary', None])
+    @pytest.mark.parametrize(("desired_range", "total_CFs"), [([1, 2.8], 6)])
+    @pytest.mark.parametrize(("version"), ['2.0', '1.0'])
+    @pytest.mark.parametrize(("posthoc_sparsity_algorithm"), ['linear', 'binary', None])
     def test_KD_tree_output(self, desired_range, sample_custom_query_2, total_CFs, version, posthoc_sparsity_algorithm):
         cf_examples = self.exp_regr._generate_counterfactuals(query_instance=sample_custom_query_2, total_CFs=total_CFs,
                                                               desired_range=desired_range,
@@ -173,7 +173,7 @@ def test_KD_tree_output(self, desired_range, sample_custom_query_2, total_CFs, v
         assert recovered_cf_examples is not None
         assert cf_examples == recovered_cf_examples
 
-    @pytest.mark.parametrize("desired_range, total_CFs", [([1, 2.8], 6)])
+    @pytest.mark.parametrize(("desired_range", "total_CFs"), [([1, 2.8], 6)])
     def test_KD_tree_counterfactual_explanations_output(self, desired_range, sample_custom_query_2,
                                                         total_CFs):
         counterfactual_explanations = self.exp_regr.generate_counterfactuals(
@@ -189,7 +189,7 @@ def test_KD_tree_counterfactual_explanations_output(self, desired_range, sample_
         assert counterfactual_explanations == recovered_counterfactual_explanations
 
     # Testing for 0 CFs needed
-    @pytest.mark.parametrize("desired_class, desired_range, total_CFs", [(0, [1, 2.8], 0)])
+    @pytest.mark.parametrize(("desired_class", "desired_range", "total_CFs"), [(0, [1, 2.8], 0)])
     def test_zero_cfs(self, desired_class, desired_range, sample_custom_query_4, total_CFs):
         self.exp_regr._generate_counterfactuals(query_instance=sample_custom_query_4, total_CFs=total_CFs,
                                                 desired_range=desired_range)

tests/test_dice_interface/test_dice_genetic.py

@@ -44,21 +44,21 @@ def _initiate_exp_object(self, genetic_binary_classification_exp_object):
         self.exp = genetic_binary_classification_exp_object  # explainer object
 
     # When invalid desired_class is given
-    @pytest.mark.parametrize("desired_class, total_CFs", [(7, 3)])
+    @pytest.mark.parametrize(("desired_class", "total_CFs"), [(7, 3)])
     def test_no_cfs(self, desired_class, sample_custom_query_1, total_CFs):
         with pytest.raises(UserConfigValidationException):
             self.exp.generate_counterfactuals(query_instances=sample_custom_query_1, total_CFs=total_CFs,
                                               desired_class=desired_class)
 
     # When a query's feature value is not within the permitted range and the feature is not allowed to vary
-    @pytest.mark.parametrize("features_to_vary, permitted_range, feature_weights",
+    @pytest.mark.parametrize(("features_to_vary", "permitted_range", "feature_weights"),
                              [(['Numerical'], {'Categorical': ['b', 'c']}, "inverse_mad")])
     def test_invalid_query_instance(self, sample_custom_query_1, features_to_vary, permitted_range, feature_weights):
         with pytest.raises(ValueError):
             self.exp.setup(features_to_vary, permitted_range, sample_custom_query_1, feature_weights)
 
     # Testing that the features_to_vary argument actually varies only the features that you wish to vary
-    @pytest.mark.parametrize("desired_class, total_CFs, features_to_vary, initialization",
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "features_to_vary", "initialization"),
                              [(1, 2, ["Numerical"], "kdtree"), (1, 2, ["Numerical"], "random")])
     def test_features_to_vary(self, desired_class, sample_custom_query_2, total_CFs, features_to_vary, initialization):
         ans = self.exp.generate_counterfactuals(query_instances=sample_custom_query_2,
@@ -74,7 +74,7 @@ def test_features_to_vary(self, desired_class, sample_custom_query_2, total_CFs,
                         range(total_CFs))
 
     # Testing that the permitted_range argument actually varies the features only within the permitted_range
-    @pytest.mark.parametrize("desired_class, total_CFs, features_to_vary, permitted_range, initialization",
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "features_to_vary", "permitted_range", "initialization"),
                              [(1, 2, "all", {'Numerical': [10, 15]}, "kdtree"),
                               (1, 2, "all", {'Numerical': [10, 15]}, "random")])
     def test_permitted_range(self, desired_class, sample_custom_query_2, total_CFs, features_to_vary, permitted_range,
@@ -92,7 +92,7 @@ def test_permitted_range(self, desired_class, sample_custom_query_2, total_CFs,
                     in range(total_CFs))
 
     # Testing if you can provide permitted_range for categorical variables
-    @pytest.mark.parametrize("desired_class, total_CFs, features_to_vary, permitted_range, initialization",
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "features_to_vary", "permitted_range", "initialization"),
                              [(1, 2, "all", {'Categorical': ['a', 'c']}, "kdtree"),
                               (1, 2, "all", {'Categorical': ['a', 'c']}, "random")])
     def test_permitted_range_categorical(self, desired_class, total_CFs, features_to_vary, sample_custom_query_2,
@@ -118,7 +118,7 @@ def test_query_instance_with_target_column(self, sample_custom_query_6):
         assert "present in query instance" in str(ve)
 
     # Testing if only valid cfs are found after maxiterations
-    @pytest.mark.parametrize("desired_class, total_CFs, initialization, maxiterations",
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "initialization", "maxiterations"),
                              [(0, 7, "kdtree", 0), (0, 7, "random", 0)])
     def test_maxiter(self, desired_class, sample_custom_query_2, total_CFs, initialization, maxiterations):
         ans = self.exp.generate_counterfactuals(query_instances=sample_custom_query_2,
@@ -129,7 +129,7 @@ def test_maxiter(self, desired_class, sample_custom_query_2, total_CFs, initiali
                 assert i == desired_class
 
     # Testing the custom predict function
-    @pytest.mark.parametrize("desired_class", [2])
+    @pytest.mark.parametrize(("desired_class"), [2])
     def test_predict_custom(self, desired_class, sample_custom_query_2, mocker):
         self.exp.data_interface.set_continuous_feature_indexes(query_instance=sample_custom_query_2)
         self.exp.yloss_type = 'hinge_loss'
@@ -145,7 +145,7 @@ def _initiate_exp_object(self, genetic_multi_classification_exp_object):
         self.exp = genetic_multi_classification_exp_object  # explainer object
 
     # Testing if only valid cfs are found after maxiterations
-    @pytest.mark.parametrize("desired_class, total_CFs, initialization, maxiterations",
+    @pytest.mark.parametrize(("desired_class", "total_CFs", "initialization", "maxiterations"),
                              [(2, 7, "kdtree", 0), (2, 7, "random", 0)])
     def test_maxiter(self, desired_class, sample_custom_query_2, total_CFs, initialization, maxiterations):
         ans = self.exp.generate_counterfactuals(query_instances=sample_custom_query_2,
@@ -156,7 +156,7 @@ def test_maxiter(self, desired_class, sample_custom_query_2, total_CFs, initiali
                 assert i == desired_class
 
     # Testing the custom predict function
-    @pytest.mark.parametrize("desired_class", [2])
+    @pytest.mark.parametrize(("desired_class"), [2])
     def test_predict_custom(self, desired_class, sample_custom_query_2, mocker):
         self.exp.data_interface.set_continuous_feature_indexes(query_instance=sample_custom_query_2)
         self.exp.yloss_type = 'hinge_loss'
@@ -172,7 +172,7 @@ def _initiate_exp_object(self, genetic_regression_exp_object):
         self.exp = genetic_regression_exp_object  # explainer object
 
     # features_range
-    @pytest.mark.parametrize("desired_range, total_CFs, initialization",
+    @pytest.mark.parametrize(("desired_range", "total_CFs", "initialization"),
                              [([1, 2.8], 2, "kdtree"), ([1, 2.8], 2, "random")])
     def test_desired_range(self, desired_range, sample_custom_query_2, total_CFs, initialization):
         ans = self.exp.generate_counterfactuals(query_instances=sample_custom_query_2,
@@ -181,11 +181,12 @@ def test_desired_range(self, desired_range, sample_custom_query_2, total_CFs, in
         for cfs_example in ans.cf_examples_list:
             assert all(
                 [desired_range[0]] * total_CFs <= cfs_example.final_cfs_df[
-                    self.exp.data_interface.outcome_name].values) and all(
+                    self.exp.data_interface.outcome_name].values)
+            assert all(
                 cfs_example.final_cfs_df[self.exp.data_interface.outcome_name].values <= [desired_range[1]] * total_CFs)
 
     # Testing if only valid cfs are found after maxiterations
-    @pytest.mark.parametrize("desired_range, total_CFs, initialization, maxiterations",
+    @pytest.mark.parametrize(("desired_range", "total_CFs", "initialization", "maxiterations"),
                              [([1, 2.8], 7, "kdtree", 0), ([1, 2.8], 7, "random", 0)])
     def test_maxiter(self, desired_range, sample_custom_query_2, total_CFs, initialization, maxiterations):
         ans = self.exp.generate_counterfactuals(query_instances=sample_custom_query_2,

tests/test_dice_interface/test_dice_pytorch.py

@@ -40,7 +40,7 @@ def _initiate_exp_object(self, pyt_exp_object, sample_adultincome_query):
         weights = np.random.rand(len(self.exp.data_interface.ohe_encoded_feature_names))
         self.exp.feature_weights_list = torch.tensor(weights)
 
-    @pytest.mark.parametrize("yloss, output", [("hinge_loss", 10.8443), ("l2_loss", 0.9999), ("log_loss", 9.8443)])
+    @pytest.mark.parametrize(("yloss", "output"), [("hinge_loss", 10.8443), ("l2_loss", 0.9999), ("log_loss", 9.8443)])
     def test_yloss(self, yloss, output):
         self.exp.yloss_type = yloss
         loss1 = self.exp.compute_yloss()
@@ -52,7 +52,7 @@ def test_proximity_loss(self):
         # proximity loss computed for given query instance and feature weights.
         assert pytest.approx(loss2.data.detach().numpy(), abs=1e-4) == 0.0068
 
-    @pytest.mark.parametrize("diversity_loss, output", [("dpp_style:inverse_dist", 0.0104), ("avg_dist", 0.1743)])
+    @pytest.mark.parametrize(("diversity_loss", "output"), [("dpp_style:inverse_dist", 0.0104), ("avg_dist", 0.1743)])
     def test_diversity_loss(self, diversity_loss, output):
         self.exp.diversity_loss_type = diversity_loss
         loss3 = self.exp.compute_diversity_loss()