ENH: rename groups into partition in tests

Author: vincentblot28

mapie/tests/test_mondrian.py

@@ -186,7 +186,7 @@ def test_valid_estimators_dont_fail(mapie_estimator_name):
     x, y = TOY_DATASETS[task]
     y = np.abs(y)  # to avoid negative values with Gamma NCS
     ml_model = ML_MODELS[task]
-    groups = np.random.choice(10, len(x))
+    partition = np.random.choice(10, len(x))
     model = clone(ml_model)
     model.fit(x, y)
     mapie_inst = deepcopy(mapie_estimator)
@@ -195,8 +195,8 @@ def test_valid_estimators_dont_fail(mapie_estimator_name):
             estimator=model, cv="prefit", **mapie_kwargs
         )
     )
-    mondrian_cp.fit(x, y, groups=groups)
-    mondrian_cp.predict(x, groups=groups, alpha=.2)
+    mondrian_cp.fit(x, y, partition=partition)
+    mondrian_cp.predict(x, partition=partition, alpha=.2)
 
 
 @pytest.mark.parametrize(
@@ -210,7 +210,7 @@ def test_non_cs_fails(mapie_estimator_name):
     task = task_dict["task"]
     x, y = TOY_DATASETS[task]
     ml_model = ML_MODELS[task]
-    groups = np.random.choice(10, len(x))
+    partition = np.random.choice(10, len(x))
     model = clone(ml_model)
     model.fit(x, y)
     mapie_inst = deepcopy(mapie_estimator)
@@ -220,7 +220,7 @@ def test_non_cs_fails(mapie_estimator_name):
         )
     )
     with pytest.raises(ValueError, match=r".*The conformity score for*"):
-        mondrian_cp.fit(x, y, groups=groups)
+        mondrian_cp.fit(x, y, partition=partition)
 
 
 @pytest.mark.parametrize("mapie_estimator_name", VALID_MAPIE_ESTIMATORS_NAMES)
@@ -233,7 +233,7 @@ def test_invalid_cv_fails(mapie_estimator_name, non_valid_cv):
     task = task_dict["task"]
     x, y = TOY_DATASETS[task]
     ml_model = ML_MODELS[task]
-    groups = np.random.choice(10, len(x))
+    partition = np.random.choice(10, len(x))
     model = clone(ml_model)
     mapie_inst = deepcopy(mapie_estimator)
     mondrian_cp = MondrianCP(
@@ -242,7 +242,7 @@ def test_invalid_cv_fails(mapie_estimator_name, non_valid_cv):
         )
     )
     with pytest.raises(ValueError, match=r".*estimator uses cv='prefit'*"):
-        mondrian_cp.fit(x, y, groups=groups)
+        mondrian_cp.fit(x, y, partition=partition)
 
 
 @pytest.mark.parametrize(
@@ -257,7 +257,7 @@ def test_non_valid_estimators_fails(mapie_estimator_name):
     x, y = TOY_DATASETS[task]
     y = np.abs(y)  # to avoid negative values with Gamma NCS
     ml_model = ML_MODELS[task]
-    groups = np.random.choice(10, len(x))
+    partition = np.random.choice(10, len(x))
     model = clone(ml_model)
     model.fit(x, y)
     mapie_inst = deepcopy(mapie_estimator)
@@ -277,89 +277,89 @@ def test_non_valid_estimators_fails(mapie_estimator_name):
         )
     with pytest.raises(ValueError, match=r".*The estimator must be a*"):
         if task == "multilabel_classification":
-            mondrian_cp.fit(x, y, groups=groups)
+            mondrian_cp.fit(x, y, partition=partition)
         elif task == "calibration":
-            mondrian_cp.fit(x, y, groups=groups, **mapie_kwargs)
+            mondrian_cp.fit(x, y, partition=partition, **mapie_kwargs)
         else:
-            mondrian_cp.fit(x, y, groups=groups, **mapie_kwargs)
+            mondrian_cp.fit(x, y, partition=partition, **mapie_kwargs)
 
 
-def test_groups_not_defined_by_integers_fails():
-    """Test that groups not defined by integers fails"""
+def test_partition_not_defined_by_integers_fails():
+    """Test that partition not defined by integers fails"""
     x, y = TOY_DATASETS["classification"]
     ml_model = ML_MODELS["classification"]
     model = clone(ml_model)
     model.fit(x, y)
     mondrian = MondrianCP(
         mapie_estimator=MapieClassifier(estimator=model, cv="prefit")
     )
-    groups = np.random.choice(10, len(x)).astype(str)
+    partition = np.random.choice(10, len(x)).astype(str)
     with pytest.raises(
-        ValueError, match=r".*The groups must be defined by integers*"
+        ValueError, match=r".*The partition must be defined by integers*"
     ):
-        mondrian.fit(x, y, groups=groups)
+        mondrian.fit(x, y, partition=partition)
 
 
-def test_groups_with_less_than_2_fails():
-    """Test that groups with less than 2 elements fails"""
+def test_partition_with_less_than_2_fails():
+    """Test that partition with less than 2 elements fails"""
     x, y = TOY_DATASETS["classification"]
     ml_model = ML_MODELS["classification"]
     model = clone(ml_model)
     model.fit(x, y)
     mondrian = MondrianCP(
         mapie_estimator=MapieClassifier(estimator=model, cv="prefit")
     )
-    groups = np.array([1] + [2] * (len(x) - 1))
+    partition = np.array([1] + [2] * (len(x) - 1))
     with pytest.raises(
         ValueError, match=r".*There must be at least 2 individuals*"
     ):
-        mondrian.fit(x, y, groups=groups)
+        mondrian.fit(x, y, partition=partition)
 
 
-def test_groups_and_x_have_same_length_in_fit():
-    """Test that groups and x have the same length in fit"""
+def test_partition_and_x_have_same_length_in_fit():
+    """Test that partition and x have the same length in fit"""
     x, y = TOY_DATASETS["classification"]
     ml_model = ML_MODELS["classification"]
     model = clone(ml_model)
     model.fit(x, y)
     mondrian = MondrianCP(
         mapie_estimator=MapieClassifier(estimator=model, cv="prefit")
     )
-    groups = np.random.choice(10, len(x) - 1)
+    partition = np.random.choice(10, len(x) - 1)
     with pytest.raises(ValueError, match=r".*he number of individuals in*"):
-        mondrian.fit(x, y, groups=groups)
+        mondrian.fit(x, y, partition=partition)
 
 
-def test_all_groups_in_predict_are_in_fit():
-    """Test that all groups in predict are in fit"""
+def test_all_partition_in_predict_are_in_fit():
+    """Test that all partition in predict are in fit"""
     x, y = TOY_DATASETS["classification"]
     ml_model = ML_MODELS["classification"]
     model = clone(ml_model)
     model.fit(x, y)
     mondrian = MondrianCP(
         mapie_estimator=MapieClassifier(estimator=model, cv="prefit")
     )
-    groups = np.random.choice(10, len(x))
-    mondrian.fit(x, y, groups=groups)
-    groups = np.array([99] * len(x))
+    partition = np.random.choice(10, len(x))
+    mondrian.fit(x, y, partition=partition)
+    partition = np.array([99] * len(x))
     with pytest.raises(ValueError, match=r".*There is at least one new*"):
-        mondrian.predict(x, groups=groups, alpha=.2)
+        mondrian.predict(x, partition=partition, alpha=.2)
 
 
-def test_groups_and_x_have_same_length_in_predict():
-    """Test that groups and x have the same length in predict"""
+def test_partition_and_x_have_same_length_in_predict():
+    """Test that partition and x have the same length in predict"""
     x, y = TOY_DATASETS["classification"]
     ml_model = ML_MODELS["classification"]
     model = clone(ml_model)
     model.fit(x, y)
     mondrian = MondrianCP(
         mapie_estimator=MapieClassifier(estimator=model, cv="prefit")
     )
-    groups = np.random.choice(10, len(x))
-    mondrian.fit(x, y, groups=groups)
-    groups = np.random.choice(10, len(x) - 1)
+    partition = np.random.choice(10, len(x))
+    mondrian.fit(x, y, partition=partition)
+    partition = np.random.choice(10, len(x) - 1)
     with pytest.raises(ValueError, match=r".*The number of individuals in*"):
-        mondrian.predict(x, groups=groups, alpha=.2)
+        mondrian.predict(x, partition=partition, alpha=.2)
 
 
 def test_alpha_none_return_one_element():
@@ -371,24 +371,24 @@ def test_alpha_none_return_one_element():
     mondrian = MondrianCP(
         mapie_estimator=MapieClassifier(estimator=model, cv="prefit")
     )
-    groups = np.random.choice(10, len(x))
-    mondrian.fit(x, y, groups=groups)
-    preds = mondrian.predict(x, groups=groups)
+    partition = np.random.choice(10, len(x))
+    mondrian.fit(x, y, partition=partition)
+    preds = mondrian.predict(x, partition=partition)
     assert len(preds) == len(x)
 
 
-def test_groups_is_list_ok():
-    """Test that the groups can be a list"""
+def test_partition_is_list_ok():
+    """Test that the partition can be a list"""
     x, y = TOY_DATASETS["classification"]
     ml_model = ML_MODELS["classification"]
     model = clone(ml_model)
     model.fit(x, y)
     mondrian = MondrianCP(
         mapie_estimator=MapieClassifier(estimator=model, cv="prefit")
     )
-    groups = np.random.choice(10, len(x)).tolist()
-    mondrian.fit(x, y, groups=groups)
-    mondrian.predict(x, groups=groups, alpha=.2)
+    partition = np.random.choice(10, len(x)).tolist()
+    mondrian.fit(x, y, partition=partition)
+    mondrian.predict(x, partition=partition, alpha=.2)
 
 
 @pytest.mark.parametrize("mapie_estimator_name", VALID_MAPIE_ESTIMATORS_NAMES)
@@ -402,7 +402,7 @@ def test_same_results_if_only_one_group(mapie_estimator_name, alpha):
     x, y = TOY_DATASETS[task]
     y = np.abs(y)
     ml_model = ML_MODELS[task]
-    groups = [0] * len(x)
+    partition = [0] * len(x)
     model = clone(ml_model)
     model.fit(x, y)
     mapie_inst_mondrian = deepcopy(mapie_estimator)
@@ -415,9 +415,9 @@ def test_same_results_if_only_one_group(mapie_estimator_name, alpha):
     mapie_classic = mapie_classic_inst(
         estimator=model, cv="prefit", random_state=0, **mapie_kwargs,
     )
-    mondrian_cp.fit(x, y, groups=groups)
+    mondrian_cp.fit(x, y, partition=partition)
     mapie_classic.fit(x, y)
-    mondrian_pred = mondrian_cp.predict(x, groups=groups, alpha=alpha)
+    mondrian_pred = mondrian_cp.predict(x, partition=partition, alpha=alpha)
     classic_pred = mapie_classic.predict(x, alpha=alpha)
     assert np.allclose(mondrian_pred[0], classic_pred[0])
     assert np.allclose(mondrian_pred[1], classic_pred[1])