fix more warnings

Author: hbaniecki

python/dalex/dalex/fairness/_group_fairness/plot.py

@@ -328,20 +328,20 @@ def plot_metric_scores(fobject,
     for metric in data.metric.unique():
         for label in data.label.unique():
             x = float(privileged_data.loc[(privileged_data.metric == metric) &
-                                          (privileged_data.label == label), :].score)
+                                          (privileged_data.label == label), :].score.iloc[0])
             if np.isnan(x):
                 lines_nan = True
                 continue
             # lines
             for subgroup in data.subgroup.unique():
                 y = float(data.loc[(data.metric == metric) &
                                    (data.label == label) &
-                                   (data.subgroup == subgroup)].subgroup_numeric)
+                                   (data.subgroup == subgroup)].subgroup_numeric.iloc[0])
                 # horizontal
 
                 x0 = float(data.loc[(data.metric == metric) &
                                     (data.label == label) &
-                                    (data.subgroup == subgroup)].score)
+                                    (data.subgroup == subgroup)].score.iloc[0])
 
                 if np.isnan(x0):
                     lines_nan = True
@@ -691,7 +691,7 @@ def plot_ceteris_paribus_cutoff(fobject,
 def plot_density(fobject,
                  other_objects,
                  title):
-    data = pd.DataFrame(columns=['y', 'y_hat', 'subgroup', 'model'])
+    data_list = []
     objects = [fobject]
     if other_objects is not None:
         for other_obj in other_objects:
@@ -703,7 +703,9 @@ def plot_density(fobject,
                                            'y_hat': y_hat,
                                            'subgroup': np.repeat(subgroup, len(y)),
                                            'model': np.repeat(obj.label, len(y))})
-            data = pd.concat([data, data_to_append])
+            data_list.append(data_to_append)
+
+    data = pd.concat(data_list)
 
     fig = go.Figure()
 

python/dalex/dalex/fairness/_group_fairness/utils.py

@@ -96,14 +96,14 @@ def __init__(self, sub_confusion_matrix):
 
     def to_vertical_DataFrame(self) -> pd.DataFrame:
 
-        columns = ['metric', 'subgroup', 'score']
-        data = pd.DataFrame(columns=columns)
+        df_list = []
         metrics = self.subgroup_confusion_matrix_metrics
         for subgroup in metrics.keys():
             metric = metrics.get(subgroup)
             subgroup_vec = np.repeat(subgroup, len(metric))
             sub_df = pd.DataFrame({'metric': metric.keys(), 'subgroup': subgroup_vec, 'score': metric.values()})
-            data = pd.concat([data, sub_df])
+            df_list.append(sub_df)
+        data = pd.concat(df_list, ignore_index=True)
         return data
 
     def to_horizontal_DataFrame(self) -> pd.DataFrame:
@@ -286,8 +286,7 @@ def calculate_regression_measures(y, y_hat, protected, privileged):
     unique_protected = np.unique(protected)
     unique_unprivileged = unique_protected[unique_protected != privileged]
 
-    data = pd.DataFrame(columns=['subgroup', 'independence', 'separation', 'sufficiency'])
-
+    data_list = []
     for unprivileged in unique_unprivileged:
         # filter elements
         array_elements = np.isin(protected, [privileged, unprivileged])
@@ -319,8 +318,12 @@ def calculate_regression_measures(y, y_hat, protected, privileged):
                                   'independence': [r_ind],
                                   'separation': [r_sep],
                                   'sufficiency': [r_suf]})
+        data_list.append(to_append)
 
-        data = pd.concat([data, to_append])
+    if data_list:
+        data = pd.concat(data_list, ignore_index=True)
+    else:
+        data = pd.DataFrame(columns=['subgroup', 'independence', 'separation', 'sufficiency'])
 
     # append the scale
     to_append = pd.DataFrame({'subgroup': [privileged],

python/dalex/dalex/model_explanations/_variable_importance/checks.py

@@ -37,7 +37,7 @@ def check_variable_groups(variable_groups, explainer):
             if not isinstance(variable_groups[key][0], str):
                 raise TypeError("variable_groups' is a dict of lists of variables")
 
-            wrong_names[i] = np.in1d(variable_groups[key], explainer.data.columns).all()
+            wrong_names[i] = np.isin(variable_groups[key], explainer.data.columns).all()
 
         wrong_names = not wrong_names.all()
 

python/dalex/test/test_arena_classification.py

@@ -60,7 +60,7 @@ def setUp(self):
             FairnessCheckContainer, ShapleyValuesDependenceContainer, ShapleyValuesVariableImportanceContainer,
             VariableAgainstAnotherContainer, VariableDistributionContainer]
 
-    @unittest.skipIf(sys.platform.startswith("win"), "requires Windows")
+
     def test_supported_plots(self):
         arena = dx.Arena()
         arena.push_model(self.exp)
@@ -74,15 +74,15 @@ def test_supported_plots(self):
         except Exception:
             pass
 
-    @unittest.skipIf(sys.platform.startswith("win"), "requires Windows")
+    @unittest.skipUnless(sys.platform.startswith("ubuntu"), "requires Ubuntu")
     def test_server(self):
         arena = dx.Arena()
         arena.push_model(self.exp)
         arena.push_model(self.exp2)
         port = get_free_port()
         try:
             arena.run_server(port=port)
-            time.sleep(2)
+            time.sleep(10)
             self.assertFalse(try_port(port))
             arena.stop_server()
         except AssertionError as e:
@@ -93,7 +93,7 @@ def test_server(self):
         except Exception:
             pass
 
-    @unittest.skipIf(sys.platform.startswith("win"), "requires Windows")
+    @unittest.skipUnless(sys.platform.startswith("ubuntu"), "requires Ubuntu")
     def test_plots(self):
         arena = dx.Arena()
         arena.push_model(self.exp)
@@ -110,7 +110,7 @@ def test_plots(self):
         except Exception:
             pass
 
-    @unittest.skipIf(sys.platform.startswith("win"), "requires Windows")
+    @unittest.skipUnless(sys.platform.startswith("ubuntu"), "requires Ubuntu")
     def test_observation_attributes(self):
         arena = dx.Arena()
         arena.push_model(self.exp)
@@ -128,7 +128,7 @@ def test_observation_attributes(self):
         except Exception:
             pass
 
-    @unittest.skipIf(sys.platform.startswith("win"), "requires Windows")
+    @unittest.skipUnless(sys.platform.startswith("ubuntu"), "requires Ubuntu")
     def test_variable_attributes(self):
         arena = dx.Arena()
         arena.push_model(self.exp)