Merge pull request #35 from Quantmetry/refacto_cross_validation

Refacto cross validation

Author: JulienRoussel77

HISTORY.rst

@@ -1,9 +1,10 @@
 =======
 History
 =======
-0.0.12 (2023-05-31)
+0.0.13 (2023-06-07)
 -------------------
 
+* Refacto cross validation
 * Fix Readme
 * Add test utils.plot
 

qolmat/benchmark/comparator.py

@@ -121,9 +121,10 @@ def evaluate_errors_sample(
                     hole_generator=self.generator_holes,
                     n_calls=self.n_calls_opt,
                 )
-                df_imputed = cv.fit_transform(df_corrupted)
+                imputer.hyperparams_optim = cv.optimize_hyperparams(df_corrupted)
             else:
-                df_imputed = imputer.fit_transform(df_corrupted)
+                imputer.hyperparams_optim = {}
+            df_imputed = imputer.fit_transform(df_corrupted)
             subset = self.generator_holes.subset
             errors = self.get_errors(df_origin[subset], df_imputed[subset], df_mask[subset])
             list_errors.append(errors)

qolmat/benchmark/cross_validation.py

@@ -207,7 +207,7 @@ def obj_func(**hyperparams_flat):
 
         return obj_func
 
-    def optimize_hyperparams(self, df: pd.DataFrame) -> Dict[str, Union[float, int, str]]:
+    def optimize_hyperparams(self, df: pd.DataFrame) -> Dict[str, Any]:
         """Optimize hyperparamaters
 
         Parameters
@@ -217,7 +217,7 @@ def optimize_hyperparams(self, df: pd.DataFrame) -> Dict[str, Union[float, int,
 
         Returns
         -------
-        Dict[str, Union[float,int, str]]
+        Dict[str, Any]
             hyperparameters optimize flat
         """
         list_spaces = get_search_space(self.dict_config_opti_imputer)
@@ -231,25 +231,5 @@ def optimize_hyperparams(self, df: pd.DataFrame) -> Dict[str, Union[float, int,
         )
 
         hyperparams_flat = {space.name: val for space, val in zip(list_spaces, res["x"])}
-        return hyperparams_flat
-
-    def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Fit and transform estimator and impute the missing values.
-
-        Parameters
-        ----------
-        df : pd.DataFrame
-            dataframe to impute
-
-        Returns
-        -------
-        pd.DataFrame
-            imputed dataframe
-        """
-
-        hyperparams_flat = self.optimize_hyperparams(df)
-        self.imputer.hyperparams_optim = deflat_hyperparams(hyperparams_flat)
-        df_imputed = self.imputer.fit_transform(df)
-
-        return df_imputed
+        hyperparams = deflat_hyperparams(hyperparams_flat)
+        return hyperparams

qolmat/imputations/imputers.py

@@ -48,8 +48,6 @@ def __init__(
         random_state: Union[None, int, np.random.RandomState] = None,
     ):
         self.hyperparams_user = hyperparams
-        self.hyperparams_optim: Dict = {}
-        self.hyperparams_local: Dict = {}
         self.groups = groups
         self.columnwise = columnwise
         self.shrink = shrink
@@ -82,7 +80,8 @@ def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:
             self.estimator.random_state = self.rng
 
         hyperparams = self.hyperparams_user.copy()
-        hyperparams.update(self.hyperparams_optim)
+        if hasattr(self, "hyperparams_optim"):
+            hyperparams.update(self.hyperparams_optim)
         cols_with_nans = df.columns[df.isna().any()]
 
         if self.groups == []:

qolmat/utils/data.py

@@ -1,6 +1,5 @@
 import os
 import zipfile
-from datetime import datetime
 from math import pi
 from typing import List, Optional
 from urllib import request
@@ -11,6 +10,22 @@
 from qolmat.benchmark import missing_patterns
 
 
+def download_data(zipname: str, urllink: str, datapath: str = "data/") -> List[pd.DataFrame]:
+    path_zip = os.path.join(datapath)
+    if not os.path.exists(path_zip + ".zip"):
+        if not os.path.exists(datapath):
+            os.mkdir(datapath)
+        request.urlretrieve(urllink + zipname + ".zip", path_zip + ".zip")
+
+    with zipfile.ZipFile(path_zip + ".zip", "r") as zip_ref:
+        zip_ref.extractall(path_zip)
+    data_folder = os.listdir(path_zip)
+    subfolder = os.path.join(path_zip, data_folder[0])
+    data_files = os.listdir(subfolder)
+    list_df = [pd.read_csv(os.path.join(subfolder, file)) for file in data_files]
+    return list_df
+
+
 def get_data(
     name_data: str = "Beijing", datapath: str = "data/", download: Optional[bool] = True
 ) -> pd.DataFrame:
@@ -32,19 +47,7 @@ def get_data(
     if name_data == "Beijing":
         urllink = "https://archive.ics.uci.edu/ml/machine-learning-databases/00501/"
         zipname = "PRSA2017_Data_20130301-20170228"
-        path_zip = os.path.join(datapath, zipname)
-
-        if not os.path.exists(path_zip + ".zip"):
-            if not os.path.exists(datapath):
-                os.mkdir(datapath)
-            request.urlretrieve(urllink + zipname + ".zip", path_zip + ".zip")
-
-        with zipfile.ZipFile(path_zip + ".zip", "r") as zip_ref:
-            zip_ref.extractall(path_zip)
-        data_folder = os.listdir(path_zip)
-        subfolder = os.path.join(path_zip, data_folder[0])
-        data_files = os.listdir(subfolder)
-        list_df = [pd.read_csv(os.path.join(subfolder, file)) for file in data_files]
+        list_df = download_data(zipname, urllink, datapath=datapath)
         list_df = [preprocess_data(df) for df in list_df]
         df = pd.concat(list_df)
         return df

tests/benchmark/test_cross_validation.py

@@ -1,11 +1,12 @@
 from typing import Dict, Union
+
 import numpy as np
 import pandas as pd
 import pytest
 
 from qolmat.benchmark import cross_validation
-from qolmat.imputations.imputers import ImputerRPCA
 from qolmat.benchmark.missing_patterns import EmpiricalHoleGenerator
+from qolmat.imputations.imputers import ImputerRPCA
 
 df_origin = pd.DataFrame({"col1": [0, np.nan, 2, 4, np.nan], "col2": [-1, np.nan, 0.5, 1, 1.5]})
 df_imputed = pd.DataFrame({"col1": [0, 1, 2, 3.5, 4], "col2": [-1.5, 0, 1.5, 2, 1.5]})
@@ -87,7 +88,6 @@ def test_benchmark_cross_validation_deflat_hyperparams(
 def test_benchmark_cross_validation_loss_function(
     df1: pd.DataFrame, df2: pd.DataFrame, df_mask: pd.DataFrame
 ) -> None:
-
     cv.loss_norm = 3
     np.testing.assert_raises(ValueError, cv.loss_function, df1, df2, df_mask)
     cv.loss_norm = 2
@@ -102,17 +102,12 @@ def test_benchmark_cross_validation_loss_function(
 def test_benchmark_cross_validation_optimize_hyperparams(df: pd.DataFrame) -> None:
     result_hp = cv.optimize_hyperparams(df)
     result_expected = {
-        "lam/col1": 4.799603622475375,
-        "lam/col2": 1.5503043695984915,
+        "lam": {
+            "col1": 4.799603622475375,
+            "col2": 1.5503043695984915,
+        },
         "tol": 0.07796932033627668,
         "max_iter": 100,
         "norm": "L1",
     }
     assert result_hp == result_expected
-
-
-@pytest.mark.parametrize("df", [df_corrupted])
-def test_benchmark_cross_validation_fit_transform(df: pd.DataFrame) -> None:
-    result_cv = cv.fit_transform(df)
-    result_expected = pd.DataFrame({"col1": [0, 2, 2, 4, 2], "col2": [1.5, 1.5, 1.5, 1.5, 1.5]})
-    np.testing.assert_allclose(result_cv, result_expected, atol=1e-5)

tests/utils/test_data.py

@@ -5,6 +5,7 @@
 import pytest
 
 from qolmat.utils import data
+from pytest_mock.plugin import MockerFixture
 
 columns = ["No", "year", "month", "day", "hour", "a", "b", "wd", "station"]
 df = pd.DataFrame(
@@ -28,33 +29,37 @@
     [[1, 2], [3, np.nan], [np.nan, 6]], columns=["a", "b"], index=index_preprocess
 )
 
+urllink = "https://archive.ics.uci.edu/ml/machine-learning-databases/00501/"
+zipname = "PRSA2017_Data_20130301-20170228"
+
+
+# @pytest.mark.parametrize("zipname, urllink", [(zipname, urllink)])
+# def test_utils_data_download_data(zipname: str, urllink: str, mocker: MockerFixture) -> None:
+#     mocker.patch("urllib.request.urlretrieve")
+#     mocker.patch("zipfile.ZipFile")
+#     list_df_result = data.download_data(zipname, urllink)
+
 
 @pytest.mark.parametrize("name_data", ["Beijing", "Artificial", "Bug"])
-def test_utils_data_get_data(name_data: str) -> None:
+def test_utils_data_get_data(name_data: str, mocker: MockerFixture) -> None:
+    mock_download = mocker.patch("qolmat.utils.data.download_data", return_value=[df])
+    mocker.patch("qolmat.utils.data.preprocess_data", return_value=df_preprocess)
+    try:
+        df_result = data.get_data(name_data=name_data)
+    except ValueError:
+        assert name_data not in ["Beijing", "Artificial"]
+        np.testing.assert_raises(ValueError, data.get_data, name_data)
+        return
+
     if name_data == "Beijing":
-        df = data.get_data(name_data=name_data)
-        expected_columns = [
-            "PM2.5",
-            "PM10",
-            "SO2",
-            "NO2",
-            "CO",
-            "O3",
-            "TEMP",
-            "PRES",
-            "DEWP",
-            "RAIN",
-            "WSPM",
-        ]
-        assert isinstance(df, pd.DataFrame)
-        assert df.columns.tolist() == expected_columns
+        assert mock_download.call_count == 1
+        pd.testing.assert_frame_equal(df_result, df_preprocess)
     elif name_data == "Artificial":
-        df = data.get_data(name_data=name_data)
         expected_columns = ["signal", "X", "A", "E"]
-        assert isinstance(df, pd.DataFrame)
-        assert df.columns.tolist() == expected_columns
+        assert isinstance(df_result, pd.DataFrame)
+        assert df_result.columns.tolist() == expected_columns
     else:
-        np.testing.assert_raises(ValueError, data.get_data, name_data)
+        assert False
 
 
 @pytest.mark.parametrize("df", [df])
@@ -72,11 +77,15 @@ def test_utils_data_add_holes(df: pd.DataFrame) -> None:
 
 
 @pytest.mark.parametrize("name_data", ["Beijing"])
-def test_utils_data_get_data_corrupted(name_data: str) -> None:
+def test_utils_data_get_data_corrupted(name_data: str, mocker: MockerFixture) -> None:
+    mock_download = mocker.patch("qolmat.utils.data.download_data", return_value=[df])
+    mocker.patch("qolmat.utils.data.preprocess_data", return_value=df_preprocess)
     df_out = data.get_data_corrupted()
-    size_df_out = df_out.shape
-    n = size_df_out[0] * size_df_out[1]
-    np.testing.assert_allclose(df_out.isna().sum().sum() / n, 0.2, atol=0.1)
+    df_result = pd.DataFrame(
+        [[1, 2], [np.nan, np.nan], [np.nan, 6]], columns=["a", "b"], index=index_preprocess
+    )
+    assert mock_download.call_count == 1
+    pd.testing.assert_frame_equal(df_result, df_out)
 
 
 @pytest.mark.parametrize("df", [df_preprocess])