From b2e27b6e586a78748e29cb2acb4dc4d4bced3fb9 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 23 Apr 2022 21:29:13 +0300 Subject: [PATCH 01/30] Implement group time series cross-validator --- mlxtend/evaluate/__init__.py | 4 +- mlxtend/evaluate/time_series.py | 197 ++++++++++++++++++++++++++++++++ 2 files changed, 200 insertions(+), 1 deletion(-) create mode 100644 mlxtend/evaluate/time_series.py diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index 18ea36e6b..8aa99469d 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -28,6 +28,7 @@ from .bias_variance_decomp import bias_variance_decomp from .accuracy import accuracy_score from .counterfactual import create_counterfactual +from .time_series import GroupTimeSeriesSplit __all__ = ["scoring", "confusion_matrix", "mcnemar_table", "mcnemar_tables", @@ -40,4 +41,5 @@ "RandomHoldoutSplit", "PredefinedHoldoutSplit", "ftest", "combined_ftest_5x2cv", "proportion_difference", "bias_variance_decomp", - "accuracy_score", "create_counterfactual"] + "accuracy_score", "create_counterfactual", + "time_series"] diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py new file mode 100644 index 000000000..c564050f9 --- /dev/null +++ b/mlxtend/evaluate/time_series.py @@ -0,0 +1,197 @@ +# mlxtend Machine Learning Library Extensions +# +# Time series cross validation with grouping. +# Author: Dmitry Labazkin +# +# License: BSD 3 clause + +from itertools import groupby + +import numpy as np +from sklearn.utils import indexable + + +class GroupTimeSeriesSplit: + """Group time series cross-validator. + + Parameters + ---------- + test_size : int + Size of test dataset. + train_size : int (default=None) + Size of train dataset. + n_splits : int (default=None) + Number of the splits. + gap_size : int (default=0) + Gap size between train and test datasets. + shift_size : int (default=1) + Step to shift for the next fold. + window_type : str (default='rolling') + Type of the window. Possible values: 'rolling', 'expanding'. + + Examples + ----------- + For usage examples, please see + http://rasbt.github.io/mlxtend/user_guide/evaluate/GroupTimeSeriesSplit/ + """ + + def __init__(self, + test_size, + train_size=None, + n_splits=None, + gap_size=0, + shift_size=1, + window_type='rolling'): + + if (train_size is None) and (n_splits is None): + raise ValueError( + 'Either train_size or n_splits have to be defined') + + if window_type not in ['rolling', 'expanding']: + raise ValueError( + 'Window type can be either "rolling" or "expanding"') + + if (train_size is not None) and (window_type == 'expanding'): + raise ValueError( + 'Train size can be specified only with rolling window') + + self.test_size = test_size + self.train_size = train_size + self.n_splits = n_splits + self.gap_size = gap_size + self.shift_size = shift_size + self.window_type = window_type + + def split(self, X, y=None, groups=None): + """Generate indices to split data into training and test set. + + Parameters + ---------- + X : array-like + Training data. + y : array-like (default=None) + Always ignored, exists for compatibility. + groups : array-like (default=None) + Array with group names or sequence numbers. + + Yields + ------ + train : ndarray + The training set indices for that split. + test : ndarray + The testing set indices for that split. + """ + test_size = self.test_size + gap = self.gap_size + shift_size = self.shift_size + X, y, groups = indexable(X, y, groups) + + if groups is None: + raise ValueError('The groups should be specified') + + group_seqs = [group[0] for group in groupby(groups)] + unique_groups, group_starts_idx = np.unique(groups, return_index=True) + + if group_seqs != sorted(unique_groups): + raise ValueError('The groups should be sorted in increasing order') + + n_groups = len(unique_groups) + self._n_groups = n_groups + groups_dict = dict(zip(unique_groups, group_starts_idx)) + n_samples = len(X) + + self._calculate_split_params() + train_size = self.train_size + n_splits = self.n_splits + train_start_idx = self._train_start_idx + train_end_idx = train_start_idx + train_size + test_start_idx = train_end_idx + gap + test_end_idx = test_start_idx + test_size + + for _ in range(n_splits): + train_idx = np.r_[slice(groups_dict[group_seqs[train_start_idx]], + groups_dict[group_seqs[train_end_idx]])] + + if test_end_idx < n_groups: + test_idx = np.r_[slice(groups_dict[group_seqs[test_start_idx]], + groups_dict[group_seqs[test_end_idx]])] + else: + test_idx = np.r_[slice(groups_dict[group_seqs[test_start_idx]], + n_samples)] + + yield train_idx, test_idx + + if self.window_type == 'rolling': + train_start_idx = train_start_idx + shift_size + + train_end_idx = train_end_idx + shift_size + test_start_idx = test_start_idx + shift_size + test_end_idx = test_end_idx + shift_size + + def get_n_splits(self, X=None, y=None, groups=None): + """Returns the number of splitting iterations in the cross-validator. + + Parameters + ---------- + X : object + Always ignored, exists for compatibility. + y : object + Always ignored, exists for compatibility. + groups : object + Always ignored, exists for compatibility. + + Returns + ------- + n_splits : int + Returns the number of splitting iterations in the cross-validator. + """ + return self.n_splits + + def _calculate_split_params(self): + train_size = self.train_size + test_size = self.test_size + n_splits = self.n_splits + gap = self.gap_size + shift_size = self.shift_size + n_groups = self._n_groups + + not_enough_data_error = ( + 'Not enough data to split number of groups ({0})' + ' for number splits ({1})' + ' with train size ({2}), test size ({3}),' + ' gap size ({4}), shift size ({5})') + + if (train_size is None) and (n_splits is not None): + train_size = n_groups - gap - test_size - (n_splits - + 1) * shift_size + self.train_size = train_size + + if train_size <= 0: + raise ValueError( + not_enough_data_error.format(n_groups, n_splits, + train_size, test_size, gap, + shift_size)) + train_start_idx = 0 + elif (n_splits is None) and (train_size is not None): + n_splits = (n_groups - train_size - gap - + test_size) // shift_size + 1 + self.n_splits = n_splits + + if self.n_splits <= 0: + raise ValueError( + not_enough_data_error.format(n_groups, n_splits, + train_size, test_size, gap, + shift_size)) + train_start_idx = n_groups - train_size - gap - test_size - ( + n_splits - 1) * shift_size + else: + train_start_idx = n_groups - train_size - gap - test_size - ( + n_splits - 1) * shift_size + + if train_start_idx < 0: + raise ValueError( + not_enough_data_error.format(n_groups, n_splits, + train_size, test_size, gap, + shift_size)) + + self._train_start_idx = train_start_idx From ea68fd0ec4f8cbe330e7213a74993cee4fa8df51 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 23 Apr 2022 21:29:45 +0300 Subject: [PATCH 02/30] Add tests --- mlxtend/evaluate/tests/test_time_series.py | 260 +++++++++++++++++++++ 1 file changed, 260 insertions(+) create mode 100644 mlxtend/evaluate/tests/test_time_series.py diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py new file mode 100644 index 000000000..f5e4c766e --- /dev/null +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -0,0 +1,260 @@ +# mlxtend Machine Learning Library Extensions +# +# Time series cross validation with grouping. +# Author: Dmitry Labazkin +# +# License: BSD 3 clause + +import numpy as np +import pytest +from mlxtend.evaluate import GroupTimeSeriesSplit + + +@pytest.fixture +def X(): + return np.array([[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], + [9], [7], [7], [7], [7]]) + + +@pytest.fixture +def y(): + return np.array([1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0]) + + +@pytest.fixture +def group_numbers(): + return np.array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5]) + + +@pytest.fixture +def not_sorted_group_numbers(): + return np.array([5, 5, 5, 5, 4, 4, 3, 3, 2, 2, 2, 1, 1, 1, 1, 0]) + + +@pytest.fixture +def not_consecutive_group_numbers(): + return np.array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 2, 2, 2, 2]) + + +@pytest.fixture +def group_names(): + return np.array([ + '2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03', + '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05', + '2021-06', '2021-06', '2021-06', '2021-06' + ]) + + +def check_splits(X, y, groups, cv_args, expected_results): + cv = GroupTimeSeriesSplit(**cv_args) + results = list(cv.split(X, y, groups)) + + assert len(results) == len(expected_results) + + for split, expected_split in zip(results, expected_results): + assert np.array_equal(split[0], expected_split[0]) + assert np.array_equal(split[1], expected_split[1]) + + return cv + + +def test_get_n_splits(X, y, group_numbers): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7, 8, + 9]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9, 10, + 11]), np.array([12, 13, 14, 15]))] + cv = check_splits(X, y, group_numbers, cv_args, expected_results) + + assert cv.get_n_splits() == len(expected_results) + + +def test_train_size(X, y, group_numbers): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7, 8, + 9]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9, 10, + 11]), np.array([12, 13, 14, 15]))] + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_train_size_group_names(X, y, group_names): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7, 8, + 9]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9, 10, + 11]), np.array([12, 13, 14, 15]))] + check_splits(X, y, group_names, cv_args, expected_results) + + +def test_n_splits(X, y, group_numbers): + cv_args = {'test_size': 2, 'n_splits': 3} + expected_results = [(np.array([0, 1, 2, 3, 4]), np.array([5, 6, 7, 8, 9])), + (np.array([1, 2, 3, 4, 5, 6, + 7]), np.array([8, 9, 10, 11])), + (np.array([5, 6, 7, 8, + 9]), np.array([10, 11, 12, 13, 14, 15]))] + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_n_splits_gap_size(X, y, group_numbers): + cv_args = {'test_size': 1, 'n_splits': 3, 'gap_size': 1} + expected_results = [(np.array([0, 1, 2, 3, 4]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9]), np.array([12, 13, 14, + 15]))] + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_n_splits_shift_size(X, y, group_numbers): + cv_args = {'test_size': 1, 'n_splits': 3, 'gap_size': 1} + expected_results = [(np.array([0, 1, 2, 3, 4]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9]), np.array([12, 13, 14, + 15]))] + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_n_splits_expanding_window(X, y, group_numbers): + cv_args = {'test_size': 3, 'n_splits': 3, 'window_type': 'expanding'} + expected_results = [(np.array([0]), np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])), + (np.array([0, 1, 2, 3, + 4]), np.array([5, 6, 7, 8, 9, 10, 11])), + (np.array([0, 1, 2, 3, 4, 5, 6, 7]), + np.array([8, 9, 10, 11, 12, 13, 14, 15]))] + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_full_usage_of_data(X, y, group_numbers): + cv_args = {'test_size': 3, 'train_size': 2, 'n_splits': 2} + expected_results = [(np.array([0, 1, 2, 3, + 4]), np.array([5, 6, 7, 8, 9, 10, 11])), + (np.array([1, 2, 3, 4, 5, 6, 7]), + np.array([8, 9, 10, 11, 12, 13, 14, 15]))] + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_partial_usage_of_data(X, y, group_numbers): + cv_args = {'test_size': 2, 'train_size': 2, 'n_splits': 2} + expected_results = [(np.array([1, 2, 3, 4, 5, 6, + 7]), np.array([8, 9, 10, 11])), + (np.array([5, 6, 7, 8, + 9]), np.array([10, 11, 12, 13, 14, 15]))] + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_not_specified_train_size_n_splits(X, y, group_numbers): + cv_args = {'test_size': 1} + expected_results = None + error_message = 'Either train_size or n_splits have to be defined' + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_bad_window_type(X, y, group_numbers): + cv_args = { + 'test_size': 1, + 'train_size': 3, + 'window_type': 'incorrect_window_type' + } + expected_results = None + error_message = 'Window type can be either "rolling" or "expanding"' + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_train_size_with_expanding_window(X, y, group_numbers): + cv_args = {'test_size': 1, 'train_size': 3, 'window_type': 'expanding'} + expected_results = None + error_message = 'Train size can be specified only with rolling window' + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_not_specified_groups(X, y): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = None + error_message = 'The groups should be specified' + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, None, cv_args, expected_results) + + +def test_not_sorted_groups(X, y, not_sorted_group_numbers): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = None + error_message = 'The groups should be sorted in increasing order' + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, not_sorted_group_numbers, cv_args, expected_results) + + +def test_not_consecutive_groups(X, y, not_consecutive_group_numbers): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = None + error_message = 'The groups should be sorted in increasing order' + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, not_consecutive_group_numbers, cv_args, + expected_results) + + +def test_too_large_train_size_(X, y, group_numbers): + cv_args = {'test_size': 1, 'train_size': 10} + expected_results = None + error_message = (r'Not enough data to split number of groups \(6\)' + r' for number splits \(-4\) with train size \(10\),' + r' test size \(1\), gap size \(0\), shift size \(1\)') + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_too_many_splits(X, y, group_numbers): + cv_args = {'test_size': 1, 'n_splits': 10} + expected_results = None + error_message = (r'Not enough data to split number of groups \(6\)' + r' for number splits \(10\) with train size \(-4\),' + r' test size \(1\), gap size \(0\), shift size \(1\)') + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_too_large_train_size_and_many_n_splits(X, y, group_numbers): + cv_args = {'test_size': 1, 'train_size': 10, 'n_splits': 10} + expected_results = None + error_message = (r'Not enough data to split number of groups \(6\)' + r' for number splits \(10\) with train size \(10\),' + r' test size \(1\), gap size \(0\), shift size \(1\)') + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_too_large_shift_size(X, y, group_numbers): + cv_args = {'test_size': 1, 'n_splits': 3, 'shift_size': 10} + expected_results = None + error_message = (r'Not enough data to split number of groups \(6\)' + r' for number splits \(3\) with train size \(-15\),' + r' test size \(1\), gap size \(0\), shift size \(10\)') + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_too_large_gap_size(X, y, group_numbers): + cv_args = {'test_size': 1, 'n_splits': 3, 'gap_size': 10} + expected_results = None + error_message = (r'Not enough data to split number of groups \(6\)' + r' for number splits \(3\) with train size \(-7\),' + r' test size \(1\), gap size \(10\), shift size \(1\)') + + with pytest.raises(ValueError, match=error_message): + check_splits(X, y, group_numbers, cv_args, expected_results) From 7db32bb871b94a4497fb19729fed633ab904d229 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 23 Apr 2022 22:27:18 +0300 Subject: [PATCH 03/30] Change non_sorted_group_numbers fixture for tests --- .vscode/settings.json | 4 ++++ conda_requirements.txt | 8 ++++++++ mlxtend/evaluate/tests/test_time_series.py | 2 +- 3 files changed, 13 insertions(+), 1 deletion(-) create mode 100644 .vscode/settings.json create mode 100644 conda_requirements.txt diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..5671e3b2e --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,4 @@ +{ + "autoDocstring.docstringFormat": "numpy", + "editor.formatOnSave": true +} \ No newline at end of file diff --git a/conda_requirements.txt b/conda_requirements.txt new file mode 100644 index 000000000..b5a770223 --- /dev/null +++ b/conda_requirements.txt @@ -0,0 +1,8 @@ +flake8>=4.0.1 +pandas>=1.3.4 +pip>=21.3.1 +pytest>=6.2.5 +scikit-learn>=1.0.1 +scipy>=1.7.3 +setuptools>=59.4.0 +markdown>=3.3.6 \ No newline at end of file diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index f5e4c766e..c88c3b559 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -28,7 +28,7 @@ def group_numbers(): @pytest.fixture def not_sorted_group_numbers(): - return np.array([5, 5, 5, 5, 4, 4, 3, 3, 2, 2, 2, 1, 1, 1, 1, 0]) + return np.array([5, 5, 5, 5, 1, 1, 1, 1, 3, 3, 2, 2, 2, 4, 4, 0]) @pytest.fixture From 06b767273e4dcbd422147a6c714c0f5b85841d38 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 23 Apr 2022 22:34:39 +0300 Subject: [PATCH 04/30] Delete mistakenly added settings.json --- .vscode/settings.json | 4 ---- 1 file changed, 4 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 5671e3b2e..000000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "autoDocstring.docstringFormat": "numpy", - "editor.formatOnSave": true -} \ No newline at end of file From e6c9c630fdc488995c5d13923a89a5c91c7ed6e6 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 23 Apr 2022 22:35:55 +0300 Subject: [PATCH 05/30] Delete mistakenly added conda_requirements.txt --- conda_requirements.txt | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 conda_requirements.txt diff --git a/conda_requirements.txt b/conda_requirements.txt deleted file mode 100644 index b5a770223..000000000 --- a/conda_requirements.txt +++ /dev/null @@ -1,8 +0,0 @@ -flake8>=4.0.1 -pandas>=1.3.4 -pip>=21.3.1 -pytest>=6.2.5 -scikit-learn>=1.0.1 -scipy>=1.7.3 -setuptools>=59.4.0 -markdown>=3.3.6 \ No newline at end of file From 09b7d05d0ca042320487a76cc0952aae00454eea Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 23 Apr 2022 22:43:55 +0300 Subject: [PATCH 06/30] Change error tests naming to be more consistent --- mlxtend/evaluate/tests/test_time_series.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index c88c3b559..c3cd24c79 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -216,7 +216,7 @@ def test_too_large_train_size_(X, y, group_numbers): check_splits(X, y, group_numbers, cv_args, expected_results) -def test_too_many_splits(X, y, group_numbers): +def test_too_large_n_splits(X, y, group_numbers): cv_args = {'test_size': 1, 'n_splits': 10} expected_results = None error_message = (r'Not enough data to split number of groups \(6\)' @@ -227,7 +227,7 @@ def test_too_many_splits(X, y, group_numbers): check_splits(X, y, group_numbers, cv_args, expected_results) -def test_too_large_train_size_and_many_n_splits(X, y, group_numbers): +def test_too_large_train_size_n_splits(X, y, group_numbers): cv_args = {'test_size': 1, 'train_size': 10, 'n_splits': 10} expected_results = None error_message = (r'Not enough data to split number of groups \(6\)' From cf01967baea1c622b5957833320021ba3850ab3b Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Thu, 28 Apr 2022 15:23:20 +0300 Subject: [PATCH 07/30] Change imported object to correct one --- mlxtend/evaluate/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index 8aa99469d..9f899c1b9 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -42,4 +42,4 @@ "ftest", "combined_ftest_5x2cv", "proportion_difference", "bias_variance_decomp", "accuracy_score", "create_counterfactual", - "time_series"] + "GroupTimeSeriesSplit"] From 0b23a1c0ccb3f11a422ef5bbabf7627d630a6d18 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Thu, 28 Apr 2022 16:02:44 +0300 Subject: [PATCH 08/30] Add test for cross_val_score --- mlxtend/evaluate/tests/test_time_series.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index c3cd24c79..e4c528d07 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -8,6 +8,8 @@ import numpy as np import pytest from mlxtend.evaluate import GroupTimeSeriesSplit +from sklearn.dummy import DummyClassifier +from sklearn.model_selection import cross_val_score @pytest.fixture @@ -258,3 +260,20 @@ def test_too_large_gap_size(X, y, group_numbers): with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) + + +def test_cross_val_score(X, y, group_numbers): + cv_args = {'test_size': 1, 'train_size': 3} + cv = GroupTimeSeriesSplit(**cv_args) + + expected_scores = np.array([0, 0.5, 0.25]) + clf = DummyClassifier(strategy='most_frequent') + scoring = 'accuracy' + cv_scores = cross_val_score(clf, + X, + y, + groups=group_numbers, + scoring=scoring, + cv=cv) + + assert np.array_equal(cv_scores, expected_scores) From afe15ffbc8f26b76d467e8ad5255d24617c360a6 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sun, 1 May 2022 08:24:31 +0300 Subject: [PATCH 09/30] Lessen the group restrictions to be only consecutive --- mlxtend/evaluate/time_series.py | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py index c564050f9..d9d766b9c 100644 --- a/mlxtend/evaluate/time_series.py +++ b/mlxtend/evaluate/time_series.py @@ -5,7 +5,7 @@ # # License: BSD 3 clause -from itertools import groupby +from itertools import accumulate, groupby import numpy as np from sklearn.utils import indexable @@ -89,15 +89,17 @@ def split(self, X, y=None, groups=None): if groups is None: raise ValueError('The groups should be specified') - group_seqs = [group[0] for group in groupby(groups)] - unique_groups, group_starts_idx = np.unique(groups, return_index=True) + group_names, group_lengths = zip( + *[(group_name, len(list(group_seq))) + for group_name, group_seq in groupby(groups)]) + n_groups = len(group_names) - if group_seqs != sorted(unique_groups): - raise ValueError('The groups should be sorted in increasing order') + if n_groups != len(set(group_names)): + raise ValueError('The groups should be consecutive') - n_groups = len(unique_groups) + group_starts_idx = [0] + list(accumulate(group_lengths))[:-1] self._n_groups = n_groups - groups_dict = dict(zip(unique_groups, group_starts_idx)) + groups_dict = dict(zip(group_names, group_starts_idx)) n_samples = len(X) self._calculate_split_params() @@ -109,15 +111,16 @@ def split(self, X, y=None, groups=None): test_end_idx = test_start_idx + test_size for _ in range(n_splits): - train_idx = np.r_[slice(groups_dict[group_seqs[train_start_idx]], - groups_dict[group_seqs[train_end_idx]])] + train_idx = np.r_[slice(groups_dict[group_names[train_start_idx]], + groups_dict[group_names[train_end_idx]])] if test_end_idx < n_groups: - test_idx = np.r_[slice(groups_dict[group_seqs[test_start_idx]], - groups_dict[group_seqs[test_end_idx]])] + test_idx = np.r_[slice( + groups_dict[group_names[test_start_idx]], + groups_dict[group_names[test_end_idx]])] else: - test_idx = np.r_[slice(groups_dict[group_seqs[test_start_idx]], - n_samples)] + test_idx = np.r_[slice( + groups_dict[group_names[test_start_idx]], n_samples)] yield train_idx, test_idx From a8ed4775ec1ffeeebdeca649d417a53d2f89ed35 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sun, 1 May 2022 08:25:31 +0300 Subject: [PATCH 10/30] Add more tests for group names --- mlxtend/evaluate/tests/test_time_series.py | 53 +++++++++++++++++++--- 1 file changed, 47 insertions(+), 6 deletions(-) diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index e4c528d07..5ad9b2548 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -47,6 +47,24 @@ def group_names(): ]) +@pytest.fixture +def not_sorted_group_names(): + return np.array([ + '2021-06', '2021-06', '2021-06', '2021-06', '2021-02', '2021-02', + '2021-02', '2021-02', '2021-04', '2021-04', '2021-03', '2021-03', + '2021-03', '2021-05', '2021-05', '2021-01' + ]) + + +@pytest.fixture +def not_consecutive_group_names(): + return np.array([ + '2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03', + '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05', + '2021-03', '2021-03', '2021-03', '2021-03' + ]) + + def check_splits(X, y, groups, cv_args, expected_results): cv = GroupTimeSeriesSplit(**cv_args) results = list(cv.split(X, y, groups)) @@ -148,6 +166,28 @@ def test_partial_usage_of_data(X, y, group_numbers): check_splits(X, y, group_numbers, cv_args, expected_results) +def test_not_sorted_group_numbers(X, y, not_sorted_group_numbers): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, + 9]), np.array([10, 11, 12])), + (np.array([4, 5, 6, 7, 8, 9, 10, 11, + 12]), np.array([13, 14])), + (np.array([8, 9, 10, 11, 12, 13, 14]), np.array([15]))] + + check_splits(X, y, not_sorted_group_numbers, cv_args, expected_results) + + +def test_not_sorted_group_names(X, y, not_sorted_group_names): + cv_args = {'test_size': 1, 'train_size': 3} + expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, + 9]), np.array([10, 11, 12])), + (np.array([4, 5, 6, 7, 8, 9, 10, 11, + 12]), np.array([13, 14])), + (np.array([8, 9, 10, 11, 12, 13, 14]), np.array([15]))] + + check_splits(X, y, not_sorted_group_names, cv_args, expected_results) + + def test_not_specified_train_size_n_splits(X, y, group_numbers): cv_args = {'test_size': 1} expected_results = None @@ -188,22 +228,23 @@ def test_not_specified_groups(X, y): check_splits(X, y, None, cv_args, expected_results) -def test_not_sorted_groups(X, y, not_sorted_group_numbers): +def test_not_consecutive_group_numbers(X, y, not_consecutive_group_numbers): cv_args = {'test_size': 1, 'train_size': 3} expected_results = None - error_message = 'The groups should be sorted in increasing order' + error_message = 'The groups should be consecutive' with pytest.raises(ValueError, match=error_message): - check_splits(X, y, not_sorted_group_numbers, cv_args, expected_results) + check_splits(X, y, not_consecutive_group_numbers, cv_args, + expected_results) -def test_not_consecutive_groups(X, y, not_consecutive_group_numbers): +def test_not_consecutive_group_names(X, y, not_consecutive_group_names): cv_args = {'test_size': 1, 'train_size': 3} expected_results = None - error_message = 'The groups should be sorted in increasing order' + error_message = 'The groups should be consecutive' with pytest.raises(ValueError, match=error_message): - check_splits(X, y, not_consecutive_group_numbers, cv_args, + check_splits(X, y, not_consecutive_group_names, cv_args, expected_results) From 04128a12489b2567b95148d3a9d59c9ad2a06dc1 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sun, 1 May 2022 08:47:45 +0300 Subject: [PATCH 11/30] Reformat using black --- mlxtend/evaluate/__init__.py | 38 ++- mlxtend/evaluate/tests/test_time_series.py | 301 ++++++++++++--------- mlxtend/evaluate/time_series.py | 110 ++++---- 3 files changed, 261 insertions(+), 188 deletions(-) diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index 9f899c1b9..f470ea0eb 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -30,16 +30,28 @@ from .counterfactual import create_counterfactual from .time_series import GroupTimeSeriesSplit -__all__ = ["scoring", "confusion_matrix", - "mcnemar_table", "mcnemar_tables", - "mcnemar", "lift_score", - "bootstrap", "permutation_test", - "BootstrapOutOfBag", "bootstrap_point632_score", - "cochrans_q", "paired_ttest_resampled", - "paired_ttest_kfold_cv", "paired_ttest_5x2cv", - "feature_importance_permutation", - "RandomHoldoutSplit", "PredefinedHoldoutSplit", - "ftest", "combined_ftest_5x2cv", - "proportion_difference", "bias_variance_decomp", - "accuracy_score", "create_counterfactual", - "GroupTimeSeriesSplit"] +__all__ = [ + "scoring", + "confusion_matrix", + "mcnemar_table", + "mcnemar_tables", + "mcnemar", + "lift_score", + "bootstrap", + "permutation_test", + "BootstrapOutOfBag", + "bootstrap_point632_score", + "cochrans_q", + "paired_ttest_resampled", + "paired_ttest_kfold_cv", + "paired_ttest_5x2cv", + "feature_importance_permutation", + "RandomHoldoutSplit", + "PredefinedHoldoutSplit", + "ftest", + "combined_ftest_5x2cv", + "proportion_difference", + "bias_variance_decomp", + "accuracy_score", + "create_counterfactual", +] diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index 5ad9b2548..d41b2ec34 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -14,8 +14,9 @@ @pytest.fixture def X(): - return np.array([[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], - [9], [7], [7], [7], [7]]) + return np.array( + [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]] + ) @pytest.fixture @@ -40,29 +41,74 @@ def not_consecutive_group_numbers(): @pytest.fixture def group_names(): - return np.array([ - '2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03', - '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05', - '2021-06', '2021-06', '2021-06', '2021-06' - ]) + return np.array( + [ + "2021-01", + "2021-02", + "2021-02", + "2021-02", + "2021-02", + "2021-03", + "2021-03", + "2021-03", + "2021-04", + "2021-04", + "2021-05", + "2021-05", + "2021-06", + "2021-06", + "2021-06", + "2021-06", + ] + ) @pytest.fixture def not_sorted_group_names(): - return np.array([ - '2021-06', '2021-06', '2021-06', '2021-06', '2021-02', '2021-02', - '2021-02', '2021-02', '2021-04', '2021-04', '2021-03', '2021-03', - '2021-03', '2021-05', '2021-05', '2021-01' - ]) + return np.array( + [ + "2021-06", + "2021-06", + "2021-06", + "2021-06", + "2021-02", + "2021-02", + "2021-02", + "2021-02", + "2021-04", + "2021-04", + "2021-03", + "2021-03", + "2021-03", + "2021-05", + "2021-05", + "2021-01", + ] + ) @pytest.fixture def not_consecutive_group_names(): - return np.array([ - '2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03', - '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05', - '2021-03', '2021-03', '2021-03', '2021-03' - ]) + return np.array( + [ + "2021-01", + "2021-02", + "2021-02", + "2021-02", + "2021-02", + "2021-03", + "2021-03", + "2021-03", + "2021-04", + "2021-04", + "2021-05", + "2021-05", + "2021-03", + "2021-03", + "2021-03", + "2021-03", + ] + ) def check_splits(X, y, groups, cv_args, expected_results): @@ -79,130 +125,128 @@ def check_splits(X, y, groups, cv_args, expected_results): def test_get_n_splits(X, y, group_numbers): - cv_args = {'test_size': 1, 'train_size': 3} - expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), - (np.array([1, 2, 3, 4, 5, 6, 7, 8, - 9]), np.array([10, 11])), - (np.array([5, 6, 7, 8, 9, 10, - 11]), np.array([12, 13, 14, 15]))] + cv_args = {"test_size": 1, "train_size": 3} + expected_results = [ + (np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9, 10, 11]), np.array([12, 13, 14, 15])), + ] cv = check_splits(X, y, group_numbers, cv_args, expected_results) assert cv.get_n_splits() == len(expected_results) def test_train_size(X, y, group_numbers): - cv_args = {'test_size': 1, 'train_size': 3} - expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), - (np.array([1, 2, 3, 4, 5, 6, 7, 8, - 9]), np.array([10, 11])), - (np.array([5, 6, 7, 8, 9, 10, - 11]), np.array([12, 13, 14, 15]))] + cv_args = {"test_size": 1, "train_size": 3} + expected_results = [ + (np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9, 10, 11]), np.array([12, 13, 14, 15])), + ] check_splits(X, y, group_numbers, cv_args, expected_results) def test_train_size_group_names(X, y, group_names): - cv_args = {'test_size': 1, 'train_size': 3} - expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), - (np.array([1, 2, 3, 4, 5, 6, 7, 8, - 9]), np.array([10, 11])), - (np.array([5, 6, 7, 8, 9, 10, - 11]), np.array([12, 13, 14, 15]))] + cv_args = {"test_size": 1, "train_size": 3} + expected_results = [ + (np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9, 10, 11]), np.array([12, 13, 14, 15])), + ] check_splits(X, y, group_names, cv_args, expected_results) def test_n_splits(X, y, group_numbers): - cv_args = {'test_size': 2, 'n_splits': 3} - expected_results = [(np.array([0, 1, 2, 3, 4]), np.array([5, 6, 7, 8, 9])), - (np.array([1, 2, 3, 4, 5, 6, - 7]), np.array([8, 9, 10, 11])), - (np.array([5, 6, 7, 8, - 9]), np.array([10, 11, 12, 13, 14, 15]))] + cv_args = {"test_size": 2, "n_splits": 3} + expected_results = [ + (np.array([0, 1, 2, 3, 4]), np.array([5, 6, 7, 8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([8, 9, 10, 11])), + (np.array([5, 6, 7, 8, 9]), np.array([10, 11, 12, 13, 14, 15])), + ] check_splits(X, y, group_numbers, cv_args, expected_results) def test_n_splits_gap_size(X, y, group_numbers): - cv_args = {'test_size': 1, 'n_splits': 3, 'gap_size': 1} - expected_results = [(np.array([0, 1, 2, 3, 4]), np.array([8, 9])), - (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([10, 11])), - (np.array([5, 6, 7, 8, 9]), np.array([12, 13, 14, - 15]))] + cv_args = {"test_size": 1, "n_splits": 3, "gap_size": 1} + expected_results = [ + (np.array([0, 1, 2, 3, 4]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9]), np.array([12, 13, 14, 15])), + ] check_splits(X, y, group_numbers, cv_args, expected_results) def test_n_splits_shift_size(X, y, group_numbers): - cv_args = {'test_size': 1, 'n_splits': 3, 'gap_size': 1} - expected_results = [(np.array([0, 1, 2, 3, 4]), np.array([8, 9])), - (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([10, 11])), - (np.array([5, 6, 7, 8, 9]), np.array([12, 13, 14, - 15]))] + cv_args = {"test_size": 1, "n_splits": 3, "gap_size": 1} + expected_results = [ + (np.array([0, 1, 2, 3, 4]), np.array([8, 9])), + (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([10, 11])), + (np.array([5, 6, 7, 8, 9]), np.array([12, 13, 14, 15])), + ] check_splits(X, y, group_numbers, cv_args, expected_results) def test_n_splits_expanding_window(X, y, group_numbers): - cv_args = {'test_size': 3, 'n_splits': 3, 'window_type': 'expanding'} - expected_results = [(np.array([0]), np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])), - (np.array([0, 1, 2, 3, - 4]), np.array([5, 6, 7, 8, 9, 10, 11])), - (np.array([0, 1, 2, 3, 4, 5, 6, 7]), - np.array([8, 9, 10, 11, 12, 13, 14, 15]))] + cv_args = {"test_size": 3, "n_splits": 3, "window_type": "expanding"} + expected_results = [ + (np.array([0]), np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])), + (np.array([0, 1, 2, 3, 4]), np.array([5, 6, 7, 8, 9, 10, 11])), + (np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9, 10, 11, 12, 13, 14, 15])), + ] check_splits(X, y, group_numbers, cv_args, expected_results) def test_full_usage_of_data(X, y, group_numbers): - cv_args = {'test_size': 3, 'train_size': 2, 'n_splits': 2} - expected_results = [(np.array([0, 1, 2, 3, - 4]), np.array([5, 6, 7, 8, 9, 10, 11])), - (np.array([1, 2, 3, 4, 5, 6, 7]), - np.array([8, 9, 10, 11, 12, 13, 14, 15]))] + cv_args = {"test_size": 3, "train_size": 2, "n_splits": 2} + expected_results = [ + (np.array([0, 1, 2, 3, 4]), np.array([5, 6, 7, 8, 9, 10, 11])), + (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([8, 9, 10, 11, 12, 13, 14, 15])), + ] check_splits(X, y, group_numbers, cv_args, expected_results) def test_partial_usage_of_data(X, y, group_numbers): - cv_args = {'test_size': 2, 'train_size': 2, 'n_splits': 2} - expected_results = [(np.array([1, 2, 3, 4, 5, 6, - 7]), np.array([8, 9, 10, 11])), - (np.array([5, 6, 7, 8, - 9]), np.array([10, 11, 12, 13, 14, 15]))] + cv_args = {"test_size": 2, "train_size": 2, "n_splits": 2} + expected_results = [ + (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([8, 9, 10, 11])), + (np.array([5, 6, 7, 8, 9]), np.array([10, 11, 12, 13, 14, 15])), + ] check_splits(X, y, group_numbers, cv_args, expected_results) def test_not_sorted_group_numbers(X, y, not_sorted_group_numbers): - cv_args = {'test_size': 1, 'train_size': 3} - expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, - 9]), np.array([10, 11, 12])), - (np.array([4, 5, 6, 7, 8, 9, 10, 11, - 12]), np.array([13, 14])), - (np.array([8, 9, 10, 11, 12, 13, 14]), np.array([15]))] + cv_args = {"test_size": 1, "train_size": 3} + expected_results = [ + (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), np.array([10, 11, 12])), + (np.array([4, 5, 6, 7, 8, 9, 10, 11, 12]), np.array([13, 14])), + (np.array([8, 9, 10, 11, 12, 13, 14]), np.array([15])), + ] check_splits(X, y, not_sorted_group_numbers, cv_args, expected_results) def test_not_sorted_group_names(X, y, not_sorted_group_names): - cv_args = {'test_size': 1, 'train_size': 3} - expected_results = [(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, - 9]), np.array([10, 11, 12])), - (np.array([4, 5, 6, 7, 8, 9, 10, 11, - 12]), np.array([13, 14])), - (np.array([8, 9, 10, 11, 12, 13, 14]), np.array([15]))] + cv_args = {"test_size": 1, "train_size": 3} + expected_results = [ + (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), np.array([10, 11, 12])), + (np.array([4, 5, 6, 7, 8, 9, 10, 11, 12]), np.array([13, 14])), + (np.array([8, 9, 10, 11, 12, 13, 14]), np.array([15])), + ] check_splits(X, y, not_sorted_group_names, cv_args, expected_results) def test_not_specified_train_size_n_splits(X, y, group_numbers): - cv_args = {'test_size': 1} + cv_args = {"test_size": 1} expected_results = None - error_message = 'Either train_size or n_splits have to be defined' + error_message = "Either train_size or n_splits have to be defined" with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) def test_bad_window_type(X, y, group_numbers): - cv_args = { - 'test_size': 1, - 'train_size': 3, - 'window_type': 'incorrect_window_type' - } + cv_args = {"test_size": 1, "train_size": 3, "window_type": "incorrect_window_type"} expected_results = None error_message = 'Window type can be either "rolling" or "expanding"' @@ -211,110 +255,113 @@ def test_bad_window_type(X, y, group_numbers): def test_train_size_with_expanding_window(X, y, group_numbers): - cv_args = {'test_size': 1, 'train_size': 3, 'window_type': 'expanding'} + cv_args = {"test_size": 1, "train_size": 3, "window_type": "expanding"} expected_results = None - error_message = 'Train size can be specified only with rolling window' + error_message = "Train size can be specified only with rolling window" with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) def test_not_specified_groups(X, y): - cv_args = {'test_size': 1, 'train_size': 3} + cv_args = {"test_size": 1, "train_size": 3} expected_results = None - error_message = 'The groups should be specified' + error_message = "The groups should be specified" with pytest.raises(ValueError, match=error_message): check_splits(X, y, None, cv_args, expected_results) def test_not_consecutive_group_numbers(X, y, not_consecutive_group_numbers): - cv_args = {'test_size': 1, 'train_size': 3} + cv_args = {"test_size": 1, "train_size": 3} expected_results = None - error_message = 'The groups should be consecutive' + error_message = "The groups should be consecutive" with pytest.raises(ValueError, match=error_message): - check_splits(X, y, not_consecutive_group_numbers, cv_args, - expected_results) + check_splits(X, y, not_consecutive_group_numbers, cv_args, expected_results) def test_not_consecutive_group_names(X, y, not_consecutive_group_names): - cv_args = {'test_size': 1, 'train_size': 3} + cv_args = {"test_size": 1, "train_size": 3} expected_results = None - error_message = 'The groups should be consecutive' + error_message = "The groups should be consecutive" with pytest.raises(ValueError, match=error_message): - check_splits(X, y, not_consecutive_group_names, cv_args, - expected_results) + check_splits(X, y, not_consecutive_group_names, cv_args, expected_results) def test_too_large_train_size_(X, y, group_numbers): - cv_args = {'test_size': 1, 'train_size': 10} + cv_args = {"test_size": 1, "train_size": 10} expected_results = None - error_message = (r'Not enough data to split number of groups \(6\)' - r' for number splits \(-4\) with train size \(10\),' - r' test size \(1\), gap size \(0\), shift size \(1\)') + error_message = ( + r"Not enough data to split number of groups \(6\)" + r" for number splits \(-4\) with train size \(10\)," + r" test size \(1\), gap size \(0\), shift size \(1\)" + ) with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) def test_too_large_n_splits(X, y, group_numbers): - cv_args = {'test_size': 1, 'n_splits': 10} + cv_args = {"test_size": 1, "n_splits": 10} expected_results = None - error_message = (r'Not enough data to split number of groups \(6\)' - r' for number splits \(10\) with train size \(-4\),' - r' test size \(1\), gap size \(0\), shift size \(1\)') + error_message = ( + r"Not enough data to split number of groups \(6\)" + r" for number splits \(10\) with train size \(-4\)," + r" test size \(1\), gap size \(0\), shift size \(1\)" + ) with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) def test_too_large_train_size_n_splits(X, y, group_numbers): - cv_args = {'test_size': 1, 'train_size': 10, 'n_splits': 10} + cv_args = {"test_size": 1, "train_size": 10, "n_splits": 10} expected_results = None - error_message = (r'Not enough data to split number of groups \(6\)' - r' for number splits \(10\) with train size \(10\),' - r' test size \(1\), gap size \(0\), shift size \(1\)') + error_message = ( + r"Not enough data to split number of groups \(6\)" + r" for number splits \(10\) with train size \(10\)," + r" test size \(1\), gap size \(0\), shift size \(1\)" + ) with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) def test_too_large_shift_size(X, y, group_numbers): - cv_args = {'test_size': 1, 'n_splits': 3, 'shift_size': 10} + cv_args = {"test_size": 1, "n_splits": 3, "shift_size": 10} expected_results = None - error_message = (r'Not enough data to split number of groups \(6\)' - r' for number splits \(3\) with train size \(-15\),' - r' test size \(1\), gap size \(0\), shift size \(10\)') + error_message = ( + r"Not enough data to split number of groups \(6\)" + r" for number splits \(3\) with train size \(-15\)," + r" test size \(1\), gap size \(0\), shift size \(10\)" + ) with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) def test_too_large_gap_size(X, y, group_numbers): - cv_args = {'test_size': 1, 'n_splits': 3, 'gap_size': 10} + cv_args = {"test_size": 1, "n_splits": 3, "gap_size": 10} expected_results = None - error_message = (r'Not enough data to split number of groups \(6\)' - r' for number splits \(3\) with train size \(-7\),' - r' test size \(1\), gap size \(10\), shift size \(1\)') + error_message = ( + r"Not enough data to split number of groups \(6\)" + r" for number splits \(3\) with train size \(-7\)," + r" test size \(1\), gap size \(10\), shift size \(1\)" + ) with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) def test_cross_val_score(X, y, group_numbers): - cv_args = {'test_size': 1, 'train_size': 3} + cv_args = {"test_size": 1, "train_size": 3} cv = GroupTimeSeriesSplit(**cv_args) expected_scores = np.array([0, 0.5, 0.25]) - clf = DummyClassifier(strategy='most_frequent') - scoring = 'accuracy' - cv_scores = cross_val_score(clf, - X, - y, - groups=group_numbers, - scoring=scoring, - cv=cv) + clf = DummyClassifier(strategy="most_frequent") + scoring = "accuracy" + cv_scores = cross_val_score(clf, X, y, groups=group_numbers, scoring=scoring, cv=cv) assert np.array_equal(cv_scores, expected_scores) diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py index d9d766b9c..982d468f1 100644 --- a/mlxtend/evaluate/time_series.py +++ b/mlxtend/evaluate/time_series.py @@ -35,25 +35,24 @@ class GroupTimeSeriesSplit: http://rasbt.github.io/mlxtend/user_guide/evaluate/GroupTimeSeriesSplit/ """ - def __init__(self, - test_size, - train_size=None, - n_splits=None, - gap_size=0, - shift_size=1, - window_type='rolling'): + def __init__( + self, + test_size, + train_size=None, + n_splits=None, + gap_size=0, + shift_size=1, + window_type="rolling", + ): if (train_size is None) and (n_splits is None): - raise ValueError( - 'Either train_size or n_splits have to be defined') + raise ValueError("Either train_size or n_splits have to be defined") - if window_type not in ['rolling', 'expanding']: - raise ValueError( - 'Window type can be either "rolling" or "expanding"') + if window_type not in ["rolling", "expanding"]: + raise ValueError('Window type can be either "rolling" or "expanding"') - if (train_size is not None) and (window_type == 'expanding'): - raise ValueError( - 'Train size can be specified only with rolling window') + if (train_size is not None) and (window_type == "expanding"): + raise ValueError("Train size can be specified only with rolling window") self.test_size = test_size self.train_size = train_size @@ -87,15 +86,18 @@ def split(self, X, y=None, groups=None): X, y, groups = indexable(X, y, groups) if groups is None: - raise ValueError('The groups should be specified') + raise ValueError("The groups should be specified") group_names, group_lengths = zip( - *[(group_name, len(list(group_seq))) - for group_name, group_seq in groupby(groups)]) + *[ + (group_name, len(list(group_seq))) + for group_name, group_seq in groupby(groups) + ] + ) n_groups = len(group_names) if n_groups != len(set(group_names)): - raise ValueError('The groups should be consecutive') + raise ValueError("The groups should be consecutive") group_starts_idx = [0] + list(accumulate(group_lengths))[:-1] self._n_groups = n_groups @@ -111,20 +113,28 @@ def split(self, X, y=None, groups=None): test_end_idx = test_start_idx + test_size for _ in range(n_splits): - train_idx = np.r_[slice(groups_dict[group_names[train_start_idx]], - groups_dict[group_names[train_end_idx]])] + train_idx = np.r_[ + slice( + groups_dict[group_names[train_start_idx]], + groups_dict[group_names[train_end_idx]], + ) + ] if test_end_idx < n_groups: - test_idx = np.r_[slice( - groups_dict[group_names[test_start_idx]], - groups_dict[group_names[test_end_idx]])] + test_idx = np.r_[ + slice( + groups_dict[group_names[test_start_idx]], + groups_dict[group_names[test_end_idx]], + ) + ] else: - test_idx = np.r_[slice( - groups_dict[group_names[test_start_idx]], n_samples)] + test_idx = np.r_[ + slice(groups_dict[group_names[test_start_idx]], n_samples) + ] yield train_idx, test_idx - if self.window_type == 'rolling': + if self.window_type == "rolling": train_start_idx = train_start_idx + shift_size train_end_idx = train_end_idx + shift_size @@ -159,42 +169,46 @@ def _calculate_split_params(self): n_groups = self._n_groups not_enough_data_error = ( - 'Not enough data to split number of groups ({0})' - ' for number splits ({1})' - ' with train size ({2}), test size ({3}),' - ' gap size ({4}), shift size ({5})') + "Not enough data to split number of groups ({0})" + " for number splits ({1})" + " with train size ({2}), test size ({3})," + " gap size ({4}), shift size ({5})" + ) if (train_size is None) and (n_splits is not None): - train_size = n_groups - gap - test_size - (n_splits - - 1) * shift_size + train_size = n_groups - gap - test_size - (n_splits - 1) * shift_size self.train_size = train_size if train_size <= 0: raise ValueError( - not_enough_data_error.format(n_groups, n_splits, - train_size, test_size, gap, - shift_size)) + not_enough_data_error.format( + n_groups, n_splits, train_size, test_size, gap, shift_size + ) + ) train_start_idx = 0 elif (n_splits is None) and (train_size is not None): - n_splits = (n_groups - train_size - gap - - test_size) // shift_size + 1 + n_splits = (n_groups - train_size - gap - test_size) // shift_size + 1 self.n_splits = n_splits if self.n_splits <= 0: raise ValueError( - not_enough_data_error.format(n_groups, n_splits, - train_size, test_size, gap, - shift_size)) - train_start_idx = n_groups - train_size - gap - test_size - ( - n_splits - 1) * shift_size + not_enough_data_error.format( + n_groups, n_splits, train_size, test_size, gap, shift_size + ) + ) + train_start_idx = ( + n_groups - train_size - gap - test_size - (n_splits - 1) * shift_size + ) else: - train_start_idx = n_groups - train_size - gap - test_size - ( - n_splits - 1) * shift_size + train_start_idx = ( + n_groups - train_size - gap - test_size - (n_splits - 1) * shift_size + ) if train_start_idx < 0: raise ValueError( - not_enough_data_error.format(n_groups, n_splits, - train_size, test_size, gap, - shift_size)) + not_enough_data_error.format( + n_groups, n_splits, train_size, test_size, gap, shift_size + ) + ) self._train_start_idx = train_start_idx From 715814557002429604f989f50642e5186f7490bd Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sun, 1 May 2022 08:52:13 +0300 Subject: [PATCH 12/30] Reformat using black with line length = 79 --- mlxtend/evaluate/tests/test_time_series.py | 47 ++++++++++++++++--- mlxtend/evaluate/time_series.py | 53 ++++++++++++++++++---- 2 files changed, 83 insertions(+), 17 deletions(-) diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index d41b2ec34..b17fb55d4 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -15,7 +15,24 @@ @pytest.fixture def X(): return np.array( - [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]] + [ + [0], + [7], + [6], + [4], + [4], + [8], + [0], + [6], + [2], + [0], + [5], + [9], + [7], + [7], + [7], + [7], + ] ) @@ -191,7 +208,10 @@ def test_n_splits_expanding_window(X, y, group_numbers): expected_results = [ (np.array([0]), np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])), (np.array([0, 1, 2, 3, 4]), np.array([5, 6, 7, 8, 9, 10, 11])), - (np.array([0, 1, 2, 3, 4, 5, 6, 7]), np.array([8, 9, 10, 11, 12, 13, 14, 15])), + ( + np.array([0, 1, 2, 3, 4, 5, 6, 7]), + np.array([8, 9, 10, 11, 12, 13, 14, 15]), + ), ] check_splits(X, y, group_numbers, cv_args, expected_results) @@ -200,7 +220,10 @@ def test_full_usage_of_data(X, y, group_numbers): cv_args = {"test_size": 3, "train_size": 2, "n_splits": 2} expected_results = [ (np.array([0, 1, 2, 3, 4]), np.array([5, 6, 7, 8, 9, 10, 11])), - (np.array([1, 2, 3, 4, 5, 6, 7]), np.array([8, 9, 10, 11, 12, 13, 14, 15])), + ( + np.array([1, 2, 3, 4, 5, 6, 7]), + np.array([8, 9, 10, 11, 12, 13, 14, 15]), + ), ] check_splits(X, y, group_numbers, cv_args, expected_results) @@ -246,7 +269,11 @@ def test_not_specified_train_size_n_splits(X, y, group_numbers): def test_bad_window_type(X, y, group_numbers): - cv_args = {"test_size": 1, "train_size": 3, "window_type": "incorrect_window_type"} + cv_args = { + "test_size": 1, + "train_size": 3, + "window_type": "incorrect_window_type", + } expected_results = None error_message = 'Window type can be either "rolling" or "expanding"' @@ -278,7 +305,9 @@ def test_not_consecutive_group_numbers(X, y, not_consecutive_group_numbers): error_message = "The groups should be consecutive" with pytest.raises(ValueError, match=error_message): - check_splits(X, y, not_consecutive_group_numbers, cv_args, expected_results) + check_splits( + X, y, not_consecutive_group_numbers, cv_args, expected_results + ) def test_not_consecutive_group_names(X, y, not_consecutive_group_names): @@ -287,7 +316,9 @@ def test_not_consecutive_group_names(X, y, not_consecutive_group_names): error_message = "The groups should be consecutive" with pytest.raises(ValueError, match=error_message): - check_splits(X, y, not_consecutive_group_names, cv_args, expected_results) + check_splits( + X, y, not_consecutive_group_names, cv_args, expected_results + ) def test_too_large_train_size_(X, y, group_numbers): @@ -362,6 +393,8 @@ def test_cross_val_score(X, y, group_numbers): expected_scores = np.array([0, 0.5, 0.25]) clf = DummyClassifier(strategy="most_frequent") scoring = "accuracy" - cv_scores = cross_val_score(clf, X, y, groups=group_numbers, scoring=scoring, cv=cv) + cv_scores = cross_val_score( + clf, X, y, groups=group_numbers, scoring=scoring, cv=cv + ) assert np.array_equal(cv_scores, expected_scores) diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py index 982d468f1..33ade28d1 100644 --- a/mlxtend/evaluate/time_series.py +++ b/mlxtend/evaluate/time_series.py @@ -46,13 +46,19 @@ def __init__( ): if (train_size is None) and (n_splits is None): - raise ValueError("Either train_size or n_splits have to be defined") + raise ValueError( + "Either train_size or n_splits have to be defined" + ) if window_type not in ["rolling", "expanding"]: - raise ValueError('Window type can be either "rolling" or "expanding"') + raise ValueError( + 'Window type can be either "rolling" or "expanding"' + ) if (train_size is not None) and (window_type == "expanding"): - raise ValueError("Train size can be specified only with rolling window") + raise ValueError( + "Train size can be specified only with rolling window" + ) self.test_size = test_size self.train_size = train_size @@ -176,38 +182,65 @@ def _calculate_split_params(self): ) if (train_size is None) and (n_splits is not None): - train_size = n_groups - gap - test_size - (n_splits - 1) * shift_size + train_size = ( + n_groups - gap - test_size - (n_splits - 1) * shift_size + ) self.train_size = train_size if train_size <= 0: raise ValueError( not_enough_data_error.format( - n_groups, n_splits, train_size, test_size, gap, shift_size + n_groups, + n_splits, + train_size, + test_size, + gap, + shift_size, ) ) train_start_idx = 0 elif (n_splits is None) and (train_size is not None): - n_splits = (n_groups - train_size - gap - test_size) // shift_size + 1 + n_splits = ( + n_groups - train_size - gap - test_size + ) // shift_size + 1 self.n_splits = n_splits if self.n_splits <= 0: raise ValueError( not_enough_data_error.format( - n_groups, n_splits, train_size, test_size, gap, shift_size + n_groups, + n_splits, + train_size, + test_size, + gap, + shift_size, ) ) train_start_idx = ( - n_groups - train_size - gap - test_size - (n_splits - 1) * shift_size + n_groups + - train_size + - gap + - test_size + - (n_splits - 1) * shift_size ) else: train_start_idx = ( - n_groups - train_size - gap - test_size - (n_splits - 1) * shift_size + n_groups + - train_size + - gap + - test_size + - (n_splits - 1) * shift_size ) if train_start_idx < 0: raise ValueError( not_enough_data_error.format( - n_groups, n_splits, train_size, test_size, gap, shift_size + n_groups, + n_splits, + train_size, + test_size, + gap, + shift_size, ) ) From 267ee40da3bcf6f5b045effe10cf9b514c649ebd Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sun, 1 May 2022 16:12:34 +0300 Subject: [PATCH 13/30] Add GroupTimeSeriesSplit to __all__ list --- mlxtend/evaluate/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index f470ea0eb..6671cf863 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -54,4 +54,5 @@ "bias_variance_decomp", "accuracy_score", "create_counterfactual", + "GroupTimeSeriesSplit" ] From 74fdbd04b2acd8938c06e66b57ff19e17e54d225 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sun, 1 May 2022 16:18:07 +0300 Subject: [PATCH 14/30] Add trailing comma --- mlxtend/evaluate/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index 6671cf863..3571832da 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -54,5 +54,5 @@ "bias_variance_decomp", "accuracy_score", "create_counterfactual", - "GroupTimeSeriesSplit" + "GroupTimeSeriesSplit", ] From 672b4364e72aff1593e5646877f9ca592721ca6b Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Mon, 2 May 2022 13:28:32 +0300 Subject: [PATCH 15/30] Implement group_starts_idx using itertools functions --- mlxtend/evaluate/time_series.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py index 33ade28d1..e78e3f6e9 100644 --- a/mlxtend/evaluate/time_series.py +++ b/mlxtend/evaluate/time_series.py @@ -5,7 +5,7 @@ # # License: BSD 3 clause -from itertools import accumulate, groupby +from itertools import accumulate, chain, groupby, islice import numpy as np from sklearn.utils import indexable @@ -105,8 +105,11 @@ def split(self, X, y=None, groups=None): if n_groups != len(set(group_names)): raise ValueError("The groups should be consecutive") - group_starts_idx = [0] + list(accumulate(group_lengths))[:-1] self._n_groups = n_groups + group_starts_idx = chain( + [0], + islice(accumulate(group_lengths), len(group_lengths) - 1), + ) groups_dict = dict(zip(group_names, group_starts_idx)) n_samples = len(X) From 8501a3727931e59d090e6155e845f1f8188851da Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Tue, 3 May 2022 08:32:21 +0300 Subject: [PATCH 16/30] Reformat using black --- mlxtend/evaluate/__init__.py | 2 +- mlxtend/evaluate/tests/test_time_series.py | 12 ++------ mlxtend/evaluate/time_series.py | 32 +++++----------------- 3 files changed, 11 insertions(+), 35 deletions(-) diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index 6671cf863..3571832da 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -54,5 +54,5 @@ "bias_variance_decomp", "accuracy_score", "create_counterfactual", - "GroupTimeSeriesSplit" + "GroupTimeSeriesSplit", ] diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index b17fb55d4..d88f01dd7 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -305,9 +305,7 @@ def test_not_consecutive_group_numbers(X, y, not_consecutive_group_numbers): error_message = "The groups should be consecutive" with pytest.raises(ValueError, match=error_message): - check_splits( - X, y, not_consecutive_group_numbers, cv_args, expected_results - ) + check_splits(X, y, not_consecutive_group_numbers, cv_args, expected_results) def test_not_consecutive_group_names(X, y, not_consecutive_group_names): @@ -316,9 +314,7 @@ def test_not_consecutive_group_names(X, y, not_consecutive_group_names): error_message = "The groups should be consecutive" with pytest.raises(ValueError, match=error_message): - check_splits( - X, y, not_consecutive_group_names, cv_args, expected_results - ) + check_splits(X, y, not_consecutive_group_names, cv_args, expected_results) def test_too_large_train_size_(X, y, group_numbers): @@ -393,8 +389,6 @@ def test_cross_val_score(X, y, group_numbers): expected_scores = np.array([0, 0.5, 0.25]) clf = DummyClassifier(strategy="most_frequent") scoring = "accuracy" - cv_scores = cross_val_score( - clf, X, y, groups=group_numbers, scoring=scoring, cv=cv - ) + cv_scores = cross_val_score(clf, X, y, groups=group_numbers, scoring=scoring, cv=cv) assert np.array_equal(cv_scores, expected_scores) diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py index e78e3f6e9..89d8e2d6c 100644 --- a/mlxtend/evaluate/time_series.py +++ b/mlxtend/evaluate/time_series.py @@ -46,19 +46,13 @@ def __init__( ): if (train_size is None) and (n_splits is None): - raise ValueError( - "Either train_size or n_splits have to be defined" - ) + raise ValueError("Either train_size or n_splits have to be defined") if window_type not in ["rolling", "expanding"]: - raise ValueError( - 'Window type can be either "rolling" or "expanding"' - ) + raise ValueError('Window type can be either "rolling" or "expanding"') if (train_size is not None) and (window_type == "expanding"): - raise ValueError( - "Train size can be specified only with rolling window" - ) + raise ValueError("Train size can be specified only with rolling window") self.test_size = test_size self.train_size = train_size @@ -185,9 +179,7 @@ def _calculate_split_params(self): ) if (train_size is None) and (n_splits is not None): - train_size = ( - n_groups - gap - test_size - (n_splits - 1) * shift_size - ) + train_size = n_groups - gap - test_size - (n_splits - 1) * shift_size self.train_size = train_size if train_size <= 0: @@ -203,9 +195,7 @@ def _calculate_split_params(self): ) train_start_idx = 0 elif (n_splits is None) and (train_size is not None): - n_splits = ( - n_groups - train_size - gap - test_size - ) // shift_size + 1 + n_splits = (n_groups - train_size - gap - test_size) // shift_size + 1 self.n_splits = n_splits if self.n_splits <= 0: @@ -220,19 +210,11 @@ def _calculate_split_params(self): ) ) train_start_idx = ( - n_groups - - train_size - - gap - - test_size - - (n_splits - 1) * shift_size + n_groups - train_size - gap - test_size - (n_splits - 1) * shift_size ) else: train_start_idx = ( - n_groups - - train_size - - gap - - test_size - - (n_splits - 1) * shift_size + n_groups - train_size - gap - test_size - (n_splits - 1) * shift_size ) if train_start_idx < 0: From be1d3cd3a10e8be4d72d906877bfad404c1ea9ff Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Tue, 3 May 2022 12:03:25 +0300 Subject: [PATCH 17/30] Fix formatting without trailing comma --- mlxtend/evaluate/tests/test_time_series.py | 19 +------------------ 1 file changed, 1 insertion(+), 18 deletions(-) diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index d88f01dd7..c378fab10 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -15,24 +15,7 @@ @pytest.fixture def X(): return np.array( - [ - [0], - [7], - [6], - [4], - [4], - [8], - [0], - [6], - [2], - [0], - [5], - [9], - [7], - [7], - [7], - [7], - ] + [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]] ) From 718aafb9df7f31d800e5122090469e5aed63717e Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Tue, 3 May 2022 12:04:18 +0300 Subject: [PATCH 18/30] Fix messages text --- mlxtend/evaluate/tests/test_time_series.py | 2 +- mlxtend/evaluate/time_series.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index c378fab10..1ec260b71 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -245,7 +245,7 @@ def test_not_sorted_group_names(X, y, not_sorted_group_names): def test_not_specified_train_size_n_splits(X, y, group_numbers): cv_args = {"test_size": 1} expected_results = None - error_message = "Either train_size or n_splits have to be defined" + error_message = "Either train_size or n_splits should be defined" with pytest.raises(ValueError, match=error_message): check_splits(X, y, group_numbers, cv_args, expected_results) diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py index 89d8e2d6c..efa7bde35 100644 --- a/mlxtend/evaluate/time_series.py +++ b/mlxtend/evaluate/time_series.py @@ -26,8 +26,8 @@ class GroupTimeSeriesSplit: Gap size between train and test datasets. shift_size : int (default=1) Step to shift for the next fold. - window_type : str (default='rolling') - Type of the window. Possible values: 'rolling', 'expanding'. + window_type : str (default="rolling") + Type of the window. Possible values: "rolling", "expanding". Examples ----------- @@ -46,7 +46,7 @@ def __init__( ): if (train_size is None) and (n_splits is None): - raise ValueError("Either train_size or n_splits have to be defined") + raise ValueError("Either train_size or n_splits should be defined") if window_type not in ["rolling", "expanding"]: raise ValueError('Window type can be either "rolling" or "expanding"') From 972b0d5b828221f3361c13c3e2376a3b0f84df8b Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Tue, 3 May 2022 13:49:00 +0300 Subject: [PATCH 19/30] Add documentation draft with navigation section --- docs/mkdocs.yml | 1 + docs/sources/USER_GUIDE_INDEX.md | 1 + .../evaluate/GroupTimeSeriesSplit.ipynb | 1741 +++++++++++++++++ 3 files changed, 1743 insertions(+) create mode 100644 docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index f7263974b..49d0ead04 100755 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -70,6 +70,7 @@ nav: - user_guide/evaluate/create_counterfactual.md - user_guide/evaluate/feature_importance_permutation.md - user_guide/evaluate/ftest.md + - user_guide/evaluate/GroupTimeSeriesSplit.md - user_guide/evaluate/lift_score.md - user_guide/evaluate/mcnemar_table.md - user_guide/evaluate/mcnemar_tables.md diff --git a/docs/sources/USER_GUIDE_INDEX.md b/docs/sources/USER_GUIDE_INDEX.md index 28b17cca6..ef264ffa9 100755 --- a/docs/sources/USER_GUIDE_INDEX.md +++ b/docs/sources/USER_GUIDE_INDEX.md @@ -36,6 +36,7 @@ - [create_counterfactual](user_guide/evaluate/create_counterfactual.md) - [feature_importance_permutation](user_guide/evaluate/feature_importance_permutation.md) - [ftest](user_guide/evaluate/ftest.md) +- [GroupTimeSeriesSplit](user_guide/evaluate/GroupTimeSeriesSplit.md) - [lift_score](user_guide/evaluate/lift_score.md) - [mcnemar_table](user_guide/evaluate/mcnemar_table.md) - [mcnemar_tables](user_guide/evaluate/mcnemar_tables.md) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb new file mode 100644 index 000000000..f66b430cc --- /dev/null +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -0,0 +1,1741 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GroupTimeSeriesSplit: A scikit-learn compatible version of the time series validation with groups" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "from IPython.display import display\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.dummy import DummyClassifier\n", + "from sklearn.model_selection import cross_val_score\n", + "\n", + "from matplotlib.patches import Patch\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import MaxNLocator\n", + "%matplotlib inline\n", + "\n", + "from mlxtend.evaluate.time_series import GroupTimeSeriesSplit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Prepare sample data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'2021-01': 0,\n", + " '2021-02': 1,\n", + " '2021-03': 2,\n", + " '2021-04': 3,\n", + " '2021-05': 4,\n", + " '2021-06': 5}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "months_map = {f'2021-0{i+1}': i for i in range(6)}\n", + "months_map" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['2021-01',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-04',\n", + " '2021-04',\n", + " '2021-05',\n", + " '2021-05',\n", + " '2021-06',\n", + " '2021-06',\n", + " '2021-06',\n", + " '2021-06']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "months = ['2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03',\n", + " '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05',\n", + " '2021-06', '2021-06', '2021-06', '2021-06']\n", + "months" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groups = np.fromiter(map(months_map.get, months), dtype='int')\n", + "groups" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Features and targets" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
num_feature
2021-010
2021-027
2021-026
2021-024
2021-024
2021-038
2021-030
2021-036
2021-042
2021-040
2021-055
2021-059
2021-067
2021-067
2021-067
2021-067
\n", + "
" + ], + "text/plain": [ + " num_feature\n", + "2021-01 0\n", + "2021-02 7\n", + "2021-02 6\n", + "2021-02 4\n", + "2021-02 4\n", + "2021-03 8\n", + "2021-03 0\n", + "2021-03 6\n", + "2021-04 2\n", + "2021-04 0\n", + "2021-05 5\n", + "2021-05 9\n", + "2021-06 7\n", + "2021-06 7\n", + "2021-06 7\n", + "2021-06 7" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "0 1\n", + "1 0\n", + "2 1\n", + "3 0\n", + "4 1\n", + "5 0\n", + "6 0\n", + "7 1\n", + "8 1\n", + "9 1\n", + "10 0\n", + "11 1\n", + "12 1\n", + "13 0\n", + "14 0\n", + "15 0\n", + "Name: target, dtype: int64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]]\n", + "target = [1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0]\n", + "\n", + "X = pd.DataFrame(data, index=months, columns=['num_feature'])\n", + "y = pd.Series(target, name='target')\n", + "\n", + "display(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define helper function" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def test_cv(X, y, groups, **cv_args):\n", + " cv = GroupTimeSeriesSplit(**cv_args)\n", + " groups = np.array(groups)\n", + " \n", + " for train_idx, test_idx in cv.split(X, groups=groups):\n", + " print('TRAIN INDICES:', train_idx)\n", + " print('TEST INDICES:', test_idx)\n", + " print('TRAIN LENGTH:', len(train_idx))\n", + " print('TEST LENGTH:', len(test_idx))\n", + " print('TRAIN GROUPS:', groups[train_idx]) \n", + " print('TEST GROUPS:', groups[test_idx])\n", + " print('TRAIN GROUP SIZE:', len(set(groups[train_idx]))) \n", + " print('TEST GROUP SIZE:', len(set(groups[test_idx])))\n", + " print('TRAIN GROUP MONTHS:', X.index[train_idx].values) \n", + " print('TEST GROUP MONTHS:', X.index[test_idx].values)\n", + " print()\n", + "\n", + "def plot_cv_indices(cv, X, y, groups, n_splits,\n", + " image_file_path=None):\n", + " \"\"\"Create a sample plot for indices of a cross-validation object.\"\"\"\n", + " \n", + " fig, ax = plt.subplots(figsize=(12, 4))\n", + " cmap_data = plt.cm.tab20\n", + " cmap_cv = plt.cm.coolwarm\n", + " lw = 10\n", + " marker_size = 200\n", + " \n", + " for split_idx, (train_idx, test_idx) in enumerate(cv.split(X=X, y=y, groups=groups)):\n", + " indices = np.array([np.nan] * len(X))\n", + " indices[test_idx] = 1\n", + " indices[train_idx] = 0\n", + " \n", + " ax.scatter(\n", + " range(len(X)),\n", + " [split_idx + 0.5] * len(X),\n", + " c=indices,\n", + " marker=\"_\",\n", + " lw=lw,\n", + " cmap=cmap_cv,\n", + " vmin=-0.4,\n", + " vmax=1.4,\n", + " s=marker_size\n", + " )\n", + " ax.scatter(\n", + " range(len(X)), [split_idx + 1.5] * len(X), \n", + " c=groups, marker=\"_\", lw=lw, \n", + " cmap=cmap_data, s=marker_size\n", + " )\n", + "\n", + " yticklabels = list(range(n_splits)) + ['group']\n", + " ax.set(\n", + " yticks=np.arange(n_splits + 1) + 0.5,\n", + " yticklabels=yticklabels,\n", + " ylabel='CV iteration',\n", + " ylim=[n_splits + 1.2, -0.2],\n", + " xlim=[-0.5, len(indices) - 0.5]\n", + " )\n", + " ax.legend(\n", + " [Patch(color=cmap_cv(0.2)), Patch(color=cmap_cv(0.8))],\n", + " [\"Training set\", \"Testing set\"],\n", + " loc=(1.02, 0.8),\n", + " fontsize=13\n", + " )\n", + " \n", + " ax.set_title('{}\\n{}'.format(type(cv).__name__, cv_args), fontsize=15)\n", + " ax.xaxis.set_major_locator(MaxNLocator(min_n_ticks=len(X), integer=True))\n", + " ax.set_xlabel(xlabel='Sample index', fontsize=13)\n", + " ax.set_ylabel(ylabel='CV iteration', fontsize=13)\n", + " ax.tick_params(axis='both', which='major', labelsize=13)\n", + " ax.tick_params(axis='both', which='minor', labelsize=13)\n", + " \n", + " plt.tight_layout()\n", + " \n", + " if image_file_path:\n", + " plt.savefig(image_file_path, bbox_inches='tight')\n", + " \n", + " plt.show()\n", + " \n", + "def plot_cv(X, y, groups, image_file_path=None, **cv_args):\n", + " cv = GroupTimeSeriesSplit(**cv_args)\n", + " cv._n_groups = len(np.unique(groups))\n", + " cv._calculate_split_params()\n", + " n_splits = cv.n_splits\n", + " \n", + " plot_cv_indices(cv, X, y, groups, n_splits,\n", + " image_file_path=image_file_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Check train/test split" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "cv_args = {\n", + " 'test_size': 3, \n", + " 'n_splits': 1\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", + "TEST INDICES: [ 8 9 10 11 12 13 14 15]\n", + "TRAIN LENGTH: 8\n", + "TEST LENGTH: 8\n", + "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", + "TEST GROUPS: [3 3 4 4 5 5 5 5]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 3\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05' '2021-06' '2021-06' '2021-06'\n", + " '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Check cross-validation split" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Success cases" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- test_size + train_size \n", + "- test_size + n_splits\n", + "- test_size + n_splits + gap_size\n", + "- test_size + n_splits + shift_size\n", + "- test_size + n_splits + expanding window\n", + "- test_size + train_size + n_splits (full usage of data)\n", + "- test_size + train_size + n_splits (partial usage of data)\n", + "- Groups are not sorted\n", + "- Group names\n", + "- Usage in CV" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**test_size + train_size**" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", + "TEST INDICES: [8 9]\n", + "TRAIN LENGTH: 8\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", + "TEST GROUPS: [3 3]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", + "\n", + "TRAIN INDICES: [1 2 3 4 5 6 7 8 9]\n", + "TEST INDICES: [10 11]\n", + "TRAIN LENGTH: 9\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: [1 1 1 1 2 2 2 3 3]\n", + "TEST GROUPS: [4 4]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", + " '2021-04' '2021-04']\n", + "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [ 5 6 7 8 9 10 11]\n", + "TEST INDICES: [12 13 14 15]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 4\n", + "TRAIN GROUPS: [2 2 2 3 3 4 4]\n", + "TEST GROUPS: [5 5 5 5]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'train_size': 3\n", + "}\n", + "\n", + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**test_size + n_splits**" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4]\n", + "TEST INDICES: [5 6 7 8 9]\n", + "TRAIN LENGTH: 5\n", + "TEST LENGTH: 5\n", + "TRAIN GROUPS: [0 1 1 1 1]\n", + "TEST GROUPS: [2 2 2 3 3]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 2\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", + "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "\n", + "TRAIN INDICES: [1 2 3 4 5 6 7]\n", + "TEST INDICES: [ 8 9 10 11]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 4\n", + "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", + "TEST GROUPS: [3 3 4 4]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 2\n", + "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [5 6 7 8 9]\n", + "TEST INDICES: [10 11 12 13 14 15]\n", + "TRAIN LENGTH: 5\n", + "TEST LENGTH: 6\n", + "TRAIN GROUPS: [2 2 2 3 3]\n", + "TEST GROUPS: [4 4 5 5 5 5]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 2\n", + "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "TEST GROUP MONTHS: ['2021-05' '2021-05' '2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 2,\n", + " 'n_splits': 3\n", + "}\n", + "\n", + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**test_size + n_splits + gap_size**" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4]\n", + "TEST INDICES: [8 9]\n", + "TRAIN LENGTH: 5\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: [0 1 1 1 1]\n", + "TEST GROUPS: [3 3]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", + "\n", + "TRAIN INDICES: [1 2 3 4 5 6 7]\n", + "TEST INDICES: [10 11]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", + "TEST GROUPS: [4 4]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", + "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [5 6 7 8 9]\n", + "TEST INDICES: [12 13 14 15]\n", + "TRAIN LENGTH: 5\n", + "TEST LENGTH: 4\n", + "TRAIN GROUPS: [2 2 2 3 3]\n", + "TEST GROUPS: [5 5 5 5]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABAP0lEQVR4nO3dd5ycVd3+8c+VSsqmkEIKJKErBJJA8BGQ34NgA6kixggqiFQpgkQQUakKwoMIggoIiIDSREAUpAsiSEJICCVATEJJI5CyyYYkm/3+/jj3wDDM9tmd3c31fr3mtTt3Ofc1Mzu7891z7nMrIjAzMzMzM7Pm61TuAGZmZmZmZh2FCywzMzMzM7MScYFlZmZmZmZWIi6wzMzMzMzMSsQFlpmZmZmZWYm4wDIzMzMzMysRF1hm1uFJOkDSPyS9I2mNpLck3S7pC+XOliNplKRowC233fGtmK2XpHMlzZS0StJCSY9JOqKEx5gj6eJStZfX7r6S/iVpqaTlkl6Q9BtJvRvZzmHZ8947u597HfbJ2+b7knYv7SMwM7P2pku5A5iZtSRJvwBOBG4Afg28A4wEvgr8XdIWETGrjBFz5gM7593fDLgJ+A7wbJHtZrdeNO4AxgHnATOAwcD/A/YGfleiYxxIem1KRtJE4Gbgt6TsAWwPfBPoB6xoRvO51+HlvGXfB34FPNqMds3MrJ2TLzRsZh2VpP2BvwCHR8T1RdbvC0yJiHlF1vWIiFUtHrIWkkYDzwOfjohHy5hjS+AV4CsRcVvBOkUz/4i05PMs6V/A0oj4YpF1jcou6TDgOqAiIooWZpIWA7+KiLOaltjMzDoCDxE0s47su8AzxYorgIi4J1dcZcO9TpF0qaS3ScUNkgZK+n02vLBK0qOSxue3U2zInqSzsg/cufu5IWY7SXo8G2r3iqQDG/ugCo+XZbpd0uGSZktaIekPkrpL+oSk/2TLHpU0oqCtDST9XNIbklZLmiZp77xN+mVfFxR5/j5UoEgaIelPkt7Nnqv7JW2dtz43rO4QSTdIWgrck637yBBBSbtlQxGrsuf/akkVeev7SbpG0jxJ70l6XdLVBdk/krswe95r/8ss+1JJl0vqVmzfgseyTy4/MAD4Sd5wzt1r29/MzDouF1hm1iFJ6kIawvWPRuw2CRgKfJ00rBBSD9jngVOBCaTfm49I2qKJ0W4B7gK+RCribpM0polt5fskaejbCaShal8BLgeuBn4JHEoadnhVwX63A4cBPwX2BZ4B7pY0Nls/E1gJXCrpc5I2KHZwSRsCTwBbA8dkx+8FPCipR8HmFwOVwMHZcYu1tyvwIKlA+jKpWN6b1IuUcwnwKeBk0mt0BmkYYM6zwERJx0saVuw4eb4HbAwcQhpOeBRwfj375DsQWEYaMrlzdnu2zj3MzKxD8jlYZtZRDQC6A2/kL5QkoHPeonV5vRnzI2JC3rZfAHYFdo+Ix7JlDwNzSMXY0U3IdU1EXJy1dT/wIvAD0jlhzdEb2D8ilmVt7w4cCfxvRPwzWzYMuEJSz4iokrQn8EXyHh/wD0lbAT8EDo6I5ZKOJBVq9wNrJT0F/CF7LLnn7mRSQTU2It7Njvcv0nP1LeCKvKxPRcR36nk8FwBPFrwebwEPSRodETOATwBXRMQtefvdmPf9GcB2pELzckmzSQXzzyOisGerMnu8NaRz87oDP5T0s9zjqUtETJVUDbwZEU/Vt72ZmXVc7sEys46u8Dyb7wFr8275H/T/VrDtJ4BFecUHEbES+Cup56Qp7sxrq4bUm/WJJraVb3KuuMq8Bqwh9SrlLwPI9eZ8htRD9C9JXXI34CHg/WGQEfFH0sQg3wL+BGxF6gm7Oa/tzwAPAMvz2qkEpuS3lbm3rgciqSepB+jWglxPkF6zHbNNnwMmSTouKwo/JCLeyLb9DPB/wLukQnC6pI0LNr8rez1y/gz0AEbXldXMzKyQCywz66jeAVaThn3l+wOwU3YrtLDg/lBgUS3bbdjEXIXtLcqO01xLC+6vASoLioY12dfcML+BwBA+XHCuBc4CNslvLCLeiYjrIuIb2brrgK/mDW8cSBpCWdjWpwvb4qPPc6H+pF7GKwvaWg10zWvveFKP1I+BmZJelfShnsCIWBcRD0XEqRExnjSUcENSoZ2v2OsCpXltzMxsPeIhgmbWIUVEtaR/A58jfQDPLV9I9gE/jRb88G4F9+eTpiQvtBGpNyRnNVA4IUL/WqIN5sPTkQ/OjlMO7wJvAQc0ZqeIWKs0/f3hwMeAaVlbdwPnFtmlsrCJeg6xNNvmLD7aqwgwL8uxlHSu3ImStiede3aTpOkR8WIt2f8haVqWO1/h65y7X67XxszM2in3YJlZR3Yp8D+Svt7E/Z8GBkv6f7kF2fC1L/LhoXdvAh/P26YTsGctbR5YsN3+wH+amK+5HiL1YK2IiMmFtyxjRZFJKgC2zL4uzGtrW+CFIm3NbEyobBjmU8DWxXIVm1Y/IqaTzovrRFY8SfpIcZxN0rExH+1F2z97PXK+BKwiXferodbwQe+gmZmtp9yDZWYdVkTcJelS4HpJnyZNCb6YNAHG57LNar3YbETcL+lJ4BZJp5N6nk4lnZtzUd6mdwLfkTQV+C/wbaBPLc1+W9Ia0gf3bwNbABOb9gib7QHSxBUPSLoQeIGUeyywQUT8gDQr4N2SrgWeBKqy9T8knQOVKzQvIc1U+LCky0k9YxsB/ws8kZ3H1RjfJ01oUUOa6bASGEEqbn8YEa9IeoL03M8g9XgdSZrxMFew3i/pZdLr/gapmDye1Lv424LjVZBmdLyaVCj+iDSBRr0TXOR5GfiipPtIP1czI6Kw987MzDo4F1hm1qFFxMmS/gkcR5pCuwJ4G/g3sHdE/L2eJg4gTZBwKal34j/AHhHxWt42Z5OGlJ1H6sX4FalYKTZT3leBX2TbvgFMiIipTXlszRURIelLpNn2vksqYN4lFU6XZ5vNAq4hnbt0LKm4fB24FrgwIqqzthZL+iRpavNfkK5BNZ9UgE1vQrYnsp7Ds0nnzXUG5gL38UHv079JU8yPAtYBU4G9IuLNbP3PSc/3haTX523S1OmfiojCXsP/I01j/0dSL9jvsuelMSaRZku8F+hJOv/s0Ua2YWZm7ZwacSF7MzNrIkmHkSaGqIiIWnvNrPVJCuCEiPhVubOYmVn753OwzMzMzMzMSsQFlpmZmZmZWYl4iKCZmZmZmVmJuAfLzMzMzMysRFxgmZmZmZmZlYgLLLN2TtJYSU9JWinpuoJ1IWn37Ptuks6SNLYFMrRI25IelXR7idvcPZs1rrH7DZJ0maT/SFojaU4zMhzWnP1bUuFznr2ui/Pub5Ut69fIdpv0mCV9WdKTkt6R9J6kmZLOlNStCW2dJenRxu7XVki6XtLkErc5Kvs9MaqR+3WTdJGkxyWtqu09Jem72fvllWwmTTOzDs8Flln7dx4wHDgk+7423YCfkC4SW2ot1fZxwA9K3GZTDQcmAAtI14laX+SugZWzFem17tdKxx8APEy6KPNepOtv/ZB0YeP1zbmk6361BT1Jr0kV6QLUtfkT6XWbDVwpaYNWyGZmVla+0LBZ+7cV8NeI+Eu5g5RaRLxY7gx5pkfERgCSLga+XOY8rSK7aO+b9W7Ycsf/bcGiRyT1Ab4j6YRYj2ZqiohZ5c6QExFLJW2YXaz6eGCPWrZbACyQ1AP4HOli1q+0YlQzs1bnHiyz9q8bsLIB21VmX6/LhgS9PyxI0gaSfi7pDUmrJU2TtHf+zpL2kzQlG4q4RNLTkv63vrbrImlbSfdJejdr9yVJ38lbXzhcLWq5HZa3zW6SHpNUlQ0ru1pSRQOenzpFRE1z26hNNnwuJG0n6YHsuXhZ0pca0UZXSRdLej17DedJujM3lC7vGDvlDet6RdKB9bT7/hDBbLjpPdmq2Vl7c7J1/SRdkx33vSzH1U14OhriHdLPfbNJOljSq9nz8YikcUV+pr4h6Yns53RJtt34gnaulzRZ0gHZa/dets82jciysaRbJS3K8sySdG7hMfLuz6nl/XBW3jajJd0rqTK73SZpSFOfr3yNLG5zF9cuyetmZtaWucAy68AiQhHxaHY39x/m84Cds9v8bNntpKFHPwX2BZ4B7lZ2TpWkzbNtHs7WHwL8FdiwAW3X5R5gHXAosB9wOVBXMbRzwe1yIIDXspy7Ag+ShvF9GfgusDfw/rlpEfFoRCi/0eyD6vUNyFsSEXF9RIwqsupm4G7gQOBV4E+SNm5gsz8gvS4/Aj5LeuzLgM4F290C3AV8CXgeuE3SmAYe41ng1Oz7L5Feg1yBdgnwKeBk0pDCM0ivDVD8MRcWA3WR1FlST0mfAk4Eft3Y3quIOCsids9rczxpCNuz2eO4m/T8FBoF3AAcDHwNeAN4XNJmBduNJD0P52bb9QXuV8OHxd0AbAIcRRpWdz7QvY7tD+TD74czsuWvZI9vC+BfwAak99hhwLbAPZIEEBFzst8Tc3KNZv/YeLSBmc3MrICHCJq1f/1oWA/WM9nXWRHxVG6hpD2BLwK7R8Rj2eJ/SNqKdK7LwcA4oDIiJuW197f62q6LpIHApsD+EfF8tvihuvYpyL0jcCRwdkQ8kS2+AHgyIibkbfcW8JCk0RExo5amq0mFXrn9IiKuBZA0BVgI7AP8pgH7fgK4OSJ+n7fs1iLbXRMRF2fHuB94kVScfbW+A0TEckkzs7tT8z+UZ8e/IiLyC5Qb62lyHdDQnsGVfFBs3ABMqmPbhjoNeAn4alas3SepK3Bh/kYRcU7ue0mdgAdIj/dQ4Jy8TQeSfp6fzLadAswiFTYNfQ0nRkSul/DRujaOiKl5uUYCpwDXR8TN2eKfkP7ZsFdErMm2mw68TPrHw721NN0S74Wq7GvfFmjbzKxNcQ+WWTslqZekb5E+sExpRlOfIX0I+5ekLrkbqdjJDYN6Hugr6feSPiepV7PCJ++SegJ+I2mCpMEN3VHSIODPpN6qc7JlPUn/xb+14HE8AawFdqytvYjYIiKOaPpDKZl/5L6JiHeARUBDe7CeAw6T9H1J2+d6KIq4M+8YNaTerE80Le5Hjj9J0nFZcV6viOiSX7zUYxdgN+B7wP7Ar5qU8sN2Au4p6Am7u3AjSR/PhlsuJBUfa4GtSec/5luUK64AImIu6b3Z0Of3OeBn2XDOEQ19EErnN90JzAWOzVv1mWx5Td77YTYwhw/e2x8REXtGxJ4NPX4DvUQqko+WNKCOn08zs3bPBZZZO6R0ftMK4HfA5RHxkQ+FjTAQGEL60Jh/O4s0XImImEn6ULsZqedqsaSbs0KnSbIP958jFXfXkk6Ef1zSuLr2yz4k3gqsAQ7N+3DcnzQc7sqCx7Ea6Jp7LG3c0oL7a0jDuxriPOAK0syL04A3JJ1UZLtFRe4PbUTG2hwP/AX4MTAzO6+p3l6xhoqIZyPiiYi4hDRE8Nhs6GpzDAHeLlj2oftK5+/9g/TzcwqpyNuJ9BwXvjaFz21uWUOf3wnAZOAXwFxJz2U9zPW5Kst3UES8l7d8IKmXrvC9vRmt/H6IiErSsMkvA4uBb7bm8c3MWpOHCJq1T/NIH/S+Ahwn6aaIeLqJbb0LvAUcUNdGEXEvcK+kvqQhhZeSzoFq8ofoiHgZOCgblrUbaWjWvZI2rmNSiYtJH3A/GRHL8pYvJZ3zcxYfHr6YM6+pOduD7IP1j4EfS9oSOAa4VNLMiLgvb9PBpEki8u835Hy5+o6/lFT4nChpe+D7wE2SprfAbJDPZl83JQ3Ba6oFQOE/CQrv70zqRfxs9vMKQPY+KFSsF3Yw8EJDwkTEW6ReyE6kXq+zSOdCjsh6ND9C0neBicAXsh6zfO+SerCuKbLr4iLLWkz2Hv8VqYA8B5ha9x5mZu2Xe7DM2qGIWJOdd3QKqYfmcw3YbU32tfC/7g+R/pO/IiImF96KHHtZdo7HnUBuhrTa2m6QiFgbEQ+TJggYSi3XWJL0deAk4IjC86kiYiXwFLB1sccRER26wMoXEa+SJqNYzQevUc77swZmH+T3B/7TiObrfa0jYjrpHKlOwMca0XZD7Zp9nd3Mdp4B9i0YrrZfwTY9sq+rcwsk7UKa+KLQ4GxdbrsRwA407vklImqy8w3PJl1vamSx7SR9GrgIOCMiHiyyyUOkSS2mFHk/zGlMphIYTeo1OzsiHqytYDQz6wjcg2XWjkVEtdIU2n0asO0aSbOBr0iaAbwHTCedsH8/8ICkC0n/be9DumjwBhHxA0lHk/6Tfx+pJ2hL0uQXN9TVdu7E+mKyXo6LSbO2/Zc0xO80YFpEvFtk+81JQ6H+Tho+9cm81bMi4m1Sr8lDkmpIsx5Wkq6780XghxFR9Po7kl4DHqvvPCxJuWtfbQX0zLv/WHZ8stkId69llsAWI+lO0vk+U4FVpKFYXYB/Fmz6bUlrgBmkC8VuQeoBaajcJBdHS/oTUBURz0t6glR0zyD1JB5JOuem1uJCUjVwTl3nYUm6j3Su3Quk8592JZ2HdUvkXRcqN+td/iyBDXAh8DRptsbrgI9nueGDyTeeIg3HvVrSz0m9WWeRen0LLQZulHQm6TU4mzRE8Pr6gmQ9YveT3lOvkCb0+B6pl+2lWra/lfR8/7Pg/fBmpOuXnUV6/u+VdG2Wbzhplsnr82YYLWz7IUjnYtWTeS+gF9kFxvPeD88U6U3L/Y4qNozSzKxDcYFl1v4F0NATxo8hFTUPkj7AbRoRc5Sut3QGaWrvEaShRc+RhgBCKsT2I/UwbUgaUnY1aUharW2TTqavzQLSLHk/BIaRhvg9QiqyitmE1GuyV3bLdzjpA+MTkv4f6YPtH0jnZM0lFYYL68jShY9OZ17MbbXc/zQfzPjWk/J8iHySdA5PrufoRdI5OYW9kF8lneNzHmmSkQn5s9HVJyLmSjqVNBzwBNJFiEcB/ybNljeKVAhNJc1eV9dFijtT/0iKZ/LarSYV4z/go7Py9aTun7ePiIjJkiaSLk+wP2n42rGkfzosz7ZZKOlg0s/2XaTp848hFfOF5mZtXUDqdZoMfK3gvKjavEeaTOYk0s96Fam4+1xErCqyfX/SOVYDSc99vrOBsyLilazwOo/0z4kepMLwIbJLG9SiIe8FgF/z4d613PvhcD5aVOZ+R603F4Y2s/WXonGXETGzNkbSLOBvEXFCubMYSJoL/LhguvSyU7pw7nVARUSsqGfzdkVSd1JB9Lm8Sw00ta1DScX5ZhHR4CGIWc/l6IiodXa+9Zmkz5P+0fHx/HPZzMw6IvdgmbV/bwKfkjQMWFDH5BDWwiQNJ81Y+MdyZ1nPjAeeb0pxJenXpB6rJaTzpc4E7m1McWW1y85vqyD1gNfQwSebMZsyZUq3Tp06Hdu5c+fDI6IvDR9hYu1DSFq2bt2662pqan694447Fj0VwgWWWft3CXATaejP70nDqcoum0Ch1uFfEVHdinFaRTYL3LBSt5t9SK1r2FbN+lxYR8S/qOO6TvUYQJrafwBpdsVbKD78r1nqez8A66JjDik5iTQktQb4ZUQsL3MesxbVpUuXq/v06bPrsGHDVnbr1u0dX/KtY4kI1qxZ03XevHknLF++fAdqueSEhwiadQCSNgA2B1aWYXaworIhU3Vd62bTtpK1rZO0O+n8tNqcHRFntUoYaxJJZwE/qWOTT9c26UR7ll1AfAjwRkQsKXces5Y2bdq0Wdttt93STp06+QN2B1ZTU6Pnn3++35gxY4pej9E9WGYdQHYSfYOutdOKziJd96Y2HirUcFNI1/6qjZ/Ltu8q4K91rJ9Zx7p2KyIW4ZkDbf3S2cVVx5e9xrWOLHEPVhEDBw6MUaNGlTuGmZmZmZXRlClTFkdE4QXIazVt2rQ5Y8aMadULeVt5TJs2beCYMWNGFVvnHqwiRo0axeTJH7m+qpmZmZmtR7KZYc0axQWWmZmZmVkL+ukf14ypWt3yn7t7dqf6jIndprX0cQr9+te/3vDSSy8dMnPmzBdbYvv2pr4LPJqZmZmZWTO0RnHVmOP07NlzXO7WpUuXHbp06bJD/rLGHvfYY499tzHFUmO3b00zZ87sJmnHWbNmdW1qG+7BMjMzMzNbj1RVVU3NfT9hwoSR1dXVuuOOO+YU23b16tXq3r27J21oBPdgmZmZmZkZAJ/4xCe2/ta3vrXJZz7zmc179+497uyzz95o1qxZXXfbbbct+/fvP6aiomLsjjvuuPXjjz/eM7fPZZddNmDEiBGj89s48sgjN/785z+/ea9evcZtsskmo2+88cZ+Td2+pqaG008/fchGG220fd++fcceccQRm+y8885bnXLKKUWvPblq1SpNnDhx5IYbbjimd+/e40aOHDn62muv7Z9bf9999/Xecccdt+7bt+/YTTbZZPRPfvKTjWpq0uUkx48fvw3A6NGjR/fs2XPcpEmThjb2OXSBZWZmZmZm77v11lsHnnjiiYuWL18+9Qc/+MGimpoaHXPMMYtef/315+fPnz9t++23r5owYcLmq1evrvVKyrfffvuAU089dcHy5cunfvvb31507LHHjqqsrKy19qhr+yuvvHLA1VdfvdGf//znVxctWjRt6NCha5555pnetbV1xRVXDHjuued6vfjiizNWrFgx9aGHHpo5ZsyYVQBTpkzZ4KCDDtry5JNPXvjOO+88d/fdd792zTXXDL7yyisHAEyePPlFgBkzZsyoqqqaetFFF81v7PPnAsvMzMzMzN631157Ldlvv/0qO3XqREVFRc2WW2655pBDDllWUVFR07t377jkkkvemj9/frcZM2Z0r62NffbZZ8lnP/vZlZ07d+bkk09evGLFis5N3f7mm28e8PWvf/3tXXfddVX37t3jnHPOWTh48OC1tbXVrVu3qKqq6vTcc8/1WLt2LVtsscXaHXfc8T2AX/7yl4P33nvvJYceeujSLl26MG7cuPe+/e1vL7r55psHNOc5y+dzsMzMzMzM7H0jR45cnX9//vz5XY477riNn3rqqYrKysoukgJgwYIFtdYSQ4cOfb8A6tOnTw3A8uXLa704b13bL1iwoOvIkSPX5NZ36tSJoUOHrvloK8mxxx77zsKFC7ueeuqpm8ydO7f7zjvvXHnJJZe8OXr06NWvv/56t6eeeqpPRUVFv9z2EaEhQ4bU2l5juQfLzMzMzMze16nTh0uEk08+efjChQu7PvXUUy+vWLFi6uuvvz4dUmHSGnmGDBmydu7cud1y92tqapg/f3632rbv2rUr559//oIZM2a8NHv27Od79OhRc9hhh40C2HjjjdccfPDBiysrK5/L3VasWDH1tddeewE++tibwgWWmZmZmZnVqrKysnOPHj1qBg0aVL1s2bJOJ5xwwsatefyJEye+c+ONNw568skne6xevVpnn332RosWLap1GvW777674vHHH++5evVq9erVq6ZXr141nTt3DoCTTjpp0T333LPhzTff3Hf16tVau3YtU6ZM2eDee+/tDaknrVOnTrz44osbNDWvCywzMzMzsxbUszvV7fk4P/3pT9965513ug4YMGDstttuu+0uu+yyonPnWkf7ldx3vvOddw4//PBFBxxwwJaDBw8e8+abb3YbM2bMyu7du9cU237+/PldDzvssE379+8/dsiQIWPeeOONbtdcc81cgJ122um922+//dXLL798oyFDhmw/cODAsYcddtimuYKtd+/eMWnSpLcOP/zwzSoqKsaedtppQxqbVxGe1r7Q+PHjY/LkyeWOYWZmZmZlJGlKRIxv6PbTpk2bM2bMmMUtmclg3bp1DB06dPtzzjnnzWOOOebdcmSYNm3awDFjxowqts49WGZmZmZm1qZdddVV/auqqlRZWdnplFNOGfbee+91Ouigg5aVO1cxLrDMzMzMzKxN++1vfzt4o402GjNs2LDtH3/88T5//vOfXx00aNC6cucqxtO0m5mZmZlZmzZlypSZ5c7QUO7BMjMzMzMzKxEXWGZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEvEsgmZmZmZmLWjpJaeOiVUrW/xzt3r0qu53ysXTWvo4jbHFFltse9ppp8078sgjl5Q7S2txgWVmZmZm1oJao7hqzHF69uw5Lvf9mjVrBNCtW7fILauqqpra2GPPnDmz28c+9rHtXnvttembb7752tzy11577YXGttVaDjrooFFdunSJW265ZW4p23WBZWZmZma2HskvoCZMmDCyurpad9xxx5wyRupQfA6WmZmZmZkB8Oqrr3b7whe+sNnAgQPHDBo0aPuJEyeOXLJkSSeAmpoaTjjhhOGDBw/evlevXuOGDx++3fnnnz8YYPz48dsAjB49enTPnj3HTZo0aSjA8OHDt7vyyis3BPjrX/9a0aVLlx2vvvrq/ptsssnoioqKsXvvvfdmufYBpk+f3n2nnXbaunfv3uO23nrrbc4999zBknasLe9f/vKXio9//OPb9O7de1z//v3H7LLLLlvl1lVWVnY66qijNh4+fPh2ffv2HbvbbrttOWPGjO4AZ5555kZ33XXXhnfccceAnj17juvZs+e46urqkjyHLrDMzMzMzIyqqirtueeeW33sYx97b86cOdNffPHFF+bNm9f1qKOOGgHwl7/8pc+tt9464Mknn3xp5cqVU//zn/+8tPvuu1cCTJ48+UWAGTNmzKiqqpp60UUXzS92jHXr1vHAAw/0mTFjxosvvvjijBdeeKHnBRdcMBhg7dq17Lfffltuu+22VQsWLHjuzjvvfO2GG24YVFfmo446atNjjjlm4fLly6fOmzdv+hlnnPH+cQ855JCRr7766gZPPfXUSwsXLpw2fvz4lfvuu+8Wq1ev1nnnnbdw//33f/eggw56p6qqampVVdXULl1KM7jPQwRL5Nw/Nq3i/dHE1nkJmpoP2n5G50vaej7r+JZf8t0m79vnlEtLlqMuTc3YWvnMzMrplltu6RcRXHrppfMAevfuve68886bt+eee36surp6Trdu3WLNmjV67rnnegwbNqx6+PDh1cOHD2/0B5BLL730rb59+9b07du35gtf+MLSZ599thfAww8/3HvevHndfvWrX73Zu3fv2GabbdYcd9xxC0855ZSRtbXVtWvXmDVrVvc333yzy4gRI6r32WefSoD58+d3ueeeezZ85ZVXnt9kk02qAS6++OJ511xzzeBHH3201+c///kVTXuW6tfhe7AkdZZ0kaS3JVVKukPSwHLnMjMzMzNrS/773/92mz9/freKioqxudvee++9lSTeeOONrvvss0/lD3/4w7d+9rOfDR08ePDYXXfddct//vOfPRtzjM6dOzNs2LD3i7JevXrVrFy5sjPA66+/3nXDDTes7t279/sTbmy66aar62rv9ttvf23WrFkbjBkzZtvNN99823POOWcwwCuvvNINYIcddtgm91j69es3trq6WnPmzOnWmMyNtT786/p0YH/gf4B3gGuBPwB7lTOUmZmZmVlbMnLkyDWjRo1aXdfMf6eeeuriU089dXFlZWWnSZMmDZswYcLm8+fPf75Tp+b324wYMWLtkiVLuqxYsUK5Iqu+YmjnnXdede+99/63pqaGf/zjH70POOCArcaOHbtqxx13XAUwc+bMGfkFXb5SZC7abou02rYcBVwYEf+NiGXA94EvSKq1q9HMzMzMbH0zYcKEZWvXrtXpp58+ZMmSJZ1qamqYPXt21xtuuKEfwCOPPNLzvvvu671q1Sr16NGjpqKiYl2uSBk6dOjaTp068eKLL27Q1OPvscceK4YOHbrmxBNP3Liqqkovv/xytyuvvHKj2rZ/7733dPnllw+YP39+l06dOjFgwIBqSdG5c+cYPnx49b777vvuEUccMWL27NldARYvXtz5hhtu6Lds2bJOABtttNHauXPndl+3bl1TIxfVoQssSf2AEcCU3LKImAUsB8aUKZaZmZmZrUfUo1dppqdr4eNUVFTUPPTQQzNfeumlHltvvfXoPn36jNtjjz22mjp1ak+AysrKzqeccsomAwcOHNu/f/+xDz/8cJ8bb7xxFkDv3r1j0qRJbx1++OGbVVRUjD3ttNOGNPb4Xbt25c4773xt+vTpPQcNGjR2//3332LChAnvdO3aNWrb5/bbb++/zTbbbNuzZ89xBx544JaTJk2a98UvfnEFwE033TR3yy23fG/33XffulevXuNGjx697W233dZfEgDHHXfc21VVVZ369+8/tqKiYmypZhHs6EMEK7KvywqWLwX65C+QdBSpt4sRI0a0eDAzMzMzWz/0O+XiaeXOUJvCi+xuscUWa++6667Zxbbdb7/9Kvfbb7+XamvrggsuWHDBBRcsyF/21ltvPZ/7fp999qmsrq6ekr/+kksumZd/f9y4ce9Nnjx5Zu7+RRddNHDYsGFrih1vgw02iMcee+y12vJUVFTUXHbZZfMuu+yyecXWb7PNNmumT5/+cm37N1WH7sECKrOvfQuW9yP1Yr0vIq6KiPERMX7QoDpngzQzMzMzsxZw//33937hhRe619TU8PTTT/e47LLLhhx44IHvljtXY3ToHqyIWCrpdWAH4DkASZuReq+mlzGamZmZmZkVmDNnTrfDDjts06VLl3bp379/9T777LPk/PPPL3pNrbaqQxdYmauA0yQ9QppF8ELg/oiYU9ZUZmZmZmb2IUcfffS7Rx99dLvqsSq0PhRYFwD9gWeA7sADwKFlTWRmZmZmZh2SImqdlGO9NX78+Jg8eXK5Y5iZmZlZGUmaEhHjG7r9tGnT/rvddtst6dSpkz9gd2A1NTV6/vnn+48ZM2azYus7+iQXZmZmZmatQtKCVatWNfk6UNY+rFq1agNJC2pb7wLLzMzMzKwEqqurz54zZ063lStX9qipqVG581hp1dTUaOXKlT3mzJnTrbq6+uzatlsfzsEyMzMzM2txO+yww/3PPvvs8bNmzfpJRAzBnRkdTY2kBdXV1WfvsMMO99e2kQssMzMzM7MSyT541/rh2zo+V9VmZmZmZmYl4gLLzMzMzMysRFxgmZmZmZmZlYgLLDMzMzMzsxJxgWVmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZibjAMjMzMzMzKxEXWGZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZmZmZmVmJuMAyMzMzMzMrERdYZmZmZmZmJeICy8zMzMzMrERcYJmZmZmZmZVIl4ZsJEnAV4HxQEX+uog4qgVymZmZmZmZtTsN7cH6NfArYBOga8HNzMzMzMzMaGAPFnAw8ImImNWSYczMzMzMzNqzhvZgVQGvt2QQMzMzMzOz9q6hBdbPgR9n52KZmZmZmZlZEQ0dIngiMBI4QdKi/BURsVXJU5mZmZmZmbVDDS2wzmvRFGZmZmZmZh1AgwqsiPh9SwcxMzMzMzNr7xrag4WknYBvkaZqfwO4NiKeaalgZmZmZmZm7U2DJrmQdADwT6AvMBXoAzwm6cCWi2ZmZmZmZta+NLQH6yfAQRHxt9wCSXsBFwB3tkQwK61z/1jd5H1/NLHBHZ3N0tSMzpe09XzQ9jM6n5Xb8ku+26T9+pxyaUlz1Kat5zMzawsaOk37KOC+gmX3k2YWNDMzMzMzMxpeYM0FPlOwbE/a+MWHJX1V0uOSlktqeheOmZmZmZlZAzR03Mi5wF2Sbgdmk3q0DgK+2UK5SmUJcCXQA7iqzFnMzMzMzKyDa+g07XdImk8qqMaTZhH8bEQ82ZLhmisi7geQtHt5k5iZmZmZ2fqgwWc+Z8VUmy6omkPSUcBRACNGjChzGjMzMzMza49qLbAk/U9EPJ19v0tt27X1XqyGioiryIYRjh8/Psocx8zMzMzM2qG6erAeBCqy75+oZZsAOpc0kZmZmZmZWTtVa4EVERV53zd0tkEzMzMzM7P1VoMKJ0lfr2X5IaWNU1qSOkvaAOiW3d8gu6nM0czMzMzMrANSRP2nG0laHhF9iix/NyI2bJFkJSDpMOC6Iqs2jYg5te03fvz4mDx5ckvFMjMzM7N2QNKUiBhf7hzWvjR06N9HenwkjQLa9MV7I+L6iFCR25xyZzMzMzMzs46nzmnaJa0lm8hC0pqC1Z2BX7dUMDMzMzMzs/amvutgfYbUe/U3YK+85TXAgoh4taWCmZmZmZmZtTd1FlgR8RiApM0jYn7rRDIzMzMzM2uf6uvBAiAi5ksaAOwEDCLvnKyIuKGFspmZmZmZmbUrDSqwJH0GuANYA/QDlmZfZwMusMzMzMzMzGj4LIIXAOdExCBgRfb1XOA3LZbMzMzMzMysnWlogbUlcGn2fW544IXAd0ucx8zMzMzMrN1qaIFVBXTPvn9H0gigG9C/RVKZmZmZmZm1Qw0tsJ4EDsi+/ztwN/Ag8O8WyGRmZmZmZtYuNWiSC+BQPijGTgW+B1QAl7REKDMzMzMzs/ao3gJLUhfgYlJRRUS8B5zfwrnMzMzMzMzanXqHCEZENfBVYHXLxzEzMzMzM2u/GnoO1t3AQS0ZxMzMzMzMrL1r6DlYXYEbJR0DzAFqcisi4qgWyGVmZmZmZtbuNLTAWgv8Mfu+c3YzMzMzMzOzPA0qsCLi8JYOYmZmZmZm1t419BwsJPWV9DVJ38/uD5E0rOWimZmZmZmZtS8NKrAk7Qi8BpwO/ChbvD1weQvlMjMzMzMza3ca2oN1KfD9iNgeqM6WPQl8siVCmZmZmZmZtUcNLbC2Ba7Pvg+AiFgB9GqBTGZmZmZmZu1SQwust4ER+QskbQG8VfJEZmZmZmZm7VRDC6zfA3+S9ClA2TlZ1wBXt1gyMzMzMzOzdqah18G6kDQc8G9Ab+AR4Jd4kgszMzMzM7P3NfQ6WOuAHwI/lDQwIha3bCwzMzMzM7P2p6HTtN+X+z6/uJJ0b0uEMjMzMzMza48aeg7WLrUs9zTtZmZmZmZmmTqHCEr6Wm47SRMB5a3eEljSUsHMzMzMzMzam/rOwTo/+9od+Gne8hpgAXBCS4QyMzMzMzNrj+ossCJiUwBJd0fEfq0TyczMzMzMrH1q0DlYLq7MzMzMzMzqV2sPlqTLIuLE7PuratsuIo5qiWBmZmZmZmbtTV1DBLvW8r2ZmZmZmZkVUWuBFRHH5n1/eOvEMbOO7Nw/Vjdpvx9NbNA10ZvN+Zqnqfmg7WdsrXzWPMsv+W6T9+1zyqUly1GXpmZ0vqSt5zODhl8Hy8zMzMzMzOrRoQssSRdKekHScknzJF0tacNy5zIzMzMzs46pQxdYwDrgUGAAMAbYGLi+nIHMzMzMzKzj6tCDyiPijLy7b0v6JXBrufKYmZmZmVnHVmcPlqS7Je0tSa0VqIXtCUwrtkLSUZImS5r89ttvt3IsMzMzMzPrCOobIvgOqcdnjqQfSRrWCplahKSDgGOAk4qtj4irImJ8RIwfNGhQ64YzMzMzM7MOoc4CK5uefRjwc+BLpELrLkl7tadeLUkHA1cD+0XEs+XOY2ZmZmZmHVO9k1xExPKIuCIixgG7AYtJvVqzJZ3Z0gGbS9LhwG+BfSPikXLnMTMzMzOzjqtRswhGxNMRcQSp0FoHnN0iqUpE0onAxcDnI+Jf5c5jZmZmZmYdmyKiYRtKXYADgaOATwP/An4bETe3XLzmkRRANbA6f3lE9K5rv/Hjx8fkyZNbMpqZmZmZtXGSpkTE+HLnsPal3mnaJW0FHAl8I9v+98AJEfFyC2drtohoN+eJmZmZmZlZ+1dngSXpMeBTpN6q7wG3RcTquvYxMzMzMzNbX9XXgzUVOCYiXmqNMGZmZmZmZu1ZfZNcXABsV2yFpK9IGlz6SGZmZmZmZu1TfQXW94Eta1m3GXBaaeOYmZmZmZm1X/UVWHsD19Sy7jpgn9LGMTMzMzMza7/qK7CGRMTCYiuy5UNKH8nMzMzMzKx9qq/AWiNpaLEV2fK1pY9kZmZmZmbWPtVXYP0LOKGWdd8BHi9tHDMzMzMzs/arvmnazwcelzQI+CPwFjAcmAgcQrpGlpmZmZmZmVFPgRURkyXtB1wBHAEEIOA1YL+IeLblI5qZmZmZmbUP9fVgEREPAFtJ2hIYBLwdEa+2eDIzMzMzM7N2pt4CKycrqlxYmZmZmZmZ1aK+SS7MzMzMzMysgVxgmZmZmZmZlYgLLDMzMzMzsxJxgWVmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZibjAMjMzMzMzKxEXWGZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZmZmZmVmJuMAyMzMzMzMrERdYZmZmZmZmJeICy8zMzMzMrERcYJmZmZmZmZWICywzMzMzM7MScYFlZmZmZmZWIl3KHaCjGHX6vU3ab84FXyxxkuK2+/12Td73+W8+X8IktWtqRudL2no+gCuOebhJ+33nN3uUOElxztc8b57+eJP33fiC3UqYpHZNzdha+R56ePMm7bfnHrNKnKS4tp7vulfnNXnfw7ccVsIktWtqRudL2no+M3APlpmZmZmZWcm4wDIzMzMzMyuRNllgSepa7gxmZmZmZmaN1WoFlqQhku6RtEzSK5KOkBSSRkm6XtJN2dd3gcuyfY6VNDPb5ylJu+W1d5akBwuO8aikM7Pvd5dULembkuZKejdrv3drPWYzMzMzM1u/tGYP1k3AGmAT4FPA1wvWHwz8HRgEfE/SROBc4BvAAOBq4D5JIxtxzM7AvsD2wMeBrYBLim0o6ShJkyVNfvvttxtxCDMzMzMzs6RVCixJGwN7AJMiYnlELCIVT/meiIhbImJdRFQBhwO/jYinI6I6In4HTAe+1sjDnxYRyyJiIfBj4BuSPvK4I+KqiBgfEeMHDRrU6MdoZmZmZmbWWj1Yw7Ovr+ctm1uwzZyC+5sAswuWzcqWN0b+ceYA3YGBjWzDzMzMzMysXq1VYL2VfR2Rt2xEwTY1BfffAEYVLNssWw5QCfQqWF/sIgf5QwpHAauBxbVHNTMzMzMza5pWKbAi4k3gUeACSRWSBgFn1rPb9cDRkj4hqYukw4GxwM3Z+inADpJ2zNYfD2xapJ2fSeojaTBwFvCHiCgs5szMzMzMzJpNEdE6B5KGkiaq2A1YCPwCuJLU6/QzoDoivl2wz/HAicBGwEzg+xHxaN76nwG5fX6Ttf1gRJwnaXfgQeAI4BygD3AP8J2IqKwr6/jx42Py5MnNeLRmZmZm1t5JmhIR48udw9qXViuwPnJg6fPAXUCPaIEQuQIrIro0dl8XWGZmZmbmAsuaotHFR1NJGks6z+p50lC+84BbWqK4MjMzMzMzK4fWvA5Wf+DPwArgCdKU6ye14vHNzMzMzMxaVKv1YEXEI8AWrXi8R2nFx2dmZmZmZtaaPVhmZmZmZmYdmgssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZmZmZmVmJuMAyMzMzMzMrERdYZmZmZmZmJeICy8zMzMzMrERcYJmZmZmZmZWICywzMzMzM7MScYFlZmZmZmZWIi6wzMzMzMzMSsQFlpmZmZmZWYm4wDIzMzMzMysRF1hmZmZmZmYl4gLLzMzMzMysRFxgmZmZmZmZlYgLLDMzMzMzsxJxgWVmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZiSgiyp2hzZH0NjC3hE0OBBaXsL1Sa+v5oO1ndL7ma+sZna952no+aPsZna/52npG52uelsg3MiIGlbhN6+BcYLUCSZMjYny5c9SmreeDtp/R+ZqvrWd0vuZp6/mg7Wd0vuZr6xmdr3naej5bf3iIoJmZmZmZWYm4wDIzMzMzMysRF1it46pyB6hHW88HbT+j8zVfW8/ofM3T1vNB28/ofM3X1jM6X/O09Xy2nvA5WGZmZmZmZiXiHiwzMzMzM7MScYFlZmZmZmZWIi6wzMzMzMzMSsQFVguS1FnSRZLellQp6Q5JA8udK0fSVyU9Lmm5pOpy5ykk6UJJL2T55km6WtKG5c6VT9L5kmZnGRdJul3SiHLnKiSpk6QnJYWkjcudB0DS9ZLWSlqRdzuu3LmKkfQZSU9lGRdLurLcmQCy90f+87cqe413KHe2HElDJN2S/R5cIulhSWPKnStH0gBJv5e0QNIySTdL6l/GPHX+Xpb0hex1XyVphqTPtZV8koZLukvS3Ozn8NDWzNbAjHtnP4OLs5/HxyXt1oby7SbpWUnvZj+Pz0r6UlvJV7DdsdnrfGZr5suOXddzuHuWK/9345OtndHWby6wWtbpwP7A/wC5D7V/KF+cj1gCXAl8t8w5arMOOBQYAIwhPYfXlzNQEX8AxkZEH2AU8Drwp7ImKu5koKrcIYr4fUT0zru1icIln6TdgduBi0k/ixsD15Qx0vsiYtv85w+4BHgxIp4td7Y8VwIbAlsBGwGTgb9KUllTfeAGoDewJbAp6TUu5+/pWn8vS9oM+DPwM6Bv9vVOSaPaQj6gBvgH8DXgzVbMVKiujP2By4EtgEHAzcDfJW3SaunqzjcTOJD0c9gv2+ZGSR9vpWzQgM8GkkYC3wOeb6VMherLuK7gb8surRfNDLqUO0AHdxRwTkT8F0DS94HXJI2MiLnljQYRcT+8/wGyzYmIM/Luvi3pl8Ct5cpTTES8nHdXpA8YW5cpTlGStgKOAw4CppY5Tnv0M+A3EXF73rK2VMAAIKkL8C1S3rZkC+BXEbEEQNLvgEmkD5CLyxlMUi9gL2BcRFRmy34KPCppRES83tqZ6vm9/E1gSkTcmN2/SdIx2fKzy50vIuYDV2Tr17VGnmLqyXhTwaJfS/oJsBPwRouHo958i3LfS+pE+pvSifQ+eqnc+fL8DvghcGwrRPqItv75xcw9WC1EUj9gBDAltywiZgHLSb0x1nh7AtPKHaKQpK9JWgasAE4Czipvog9kf6CvBU4FlpY3TVEHZUNhXlEaTtu73IHyZR/APwF0yYbqLJb0qKTx5c5WxAGkXo0bypyj0EWk13mQpA1I/3h6IiLKWlxllHfLyf1dHNvqaeo3hry/KZln8d+UJpO0HTCQ8vXEFCVpKbAaeBx4mtQz2CZIOhpYGRG3lDtLHTpLeiMb+ntvWxqWbOsHF1gtpyL7uqxg+VKgT+tGaf8kHQQcQypg2pSIuDki+gJDScVVW/pDfRKwICLuLHeQIi4HPkb6cHMg8L/A1WVN9FH9Sb8nJwKHAcNIH3T+lv0TpS05GrglIpaWO0iBfwGdgUWkf0J8CTiyrIkyEbECeBQ4S1I/SYOAXM95W/w9XYH/ppSMpMHAHcDFEfFqufPki4h+pKGrBwJ/A9rEedJK5xifSRoV0Va9TPoHyaakvzHTgYclDStnKFu/uMBqOZXZ174Fy/uRerGsgSQdTPrgvV8bO7fkQyJiASnnX9UGJuOQtAVpjPzx5c5STERMiYiFEVETES+QzhP7sqTu5c6WJ/c+vi4ipkfEGtIQvK5AmxnTL2lzUg/vb8qdJV/Wg/og8Arpd2FP4HzgcUkblTNbnkNJPQUvAf8B7sqWt4UetkKV+G9KSWQfth8h/cPkB2WOU1RErI6Iv5D++fTtMsfJuQY4LyLeKneQ2kTEgoiYFhHVEbE0In4AvEsaDmzWKlxgtZDsv8ivA+/P5pWdoNyH9N8UawBJhwO/BfaNiEfKnacBugC9SD0d5fYp0kncMyQt5oPzhqarbc7WV5N9bSuTHxARy4A5QBSuKrKsnI4GpkXE0+UOUmBD0n+RL4+I5RGxJiKuIf3t2bm80ZKIeCsiJkTE0IjYFJgNvAc8VeZoxUwj729KZhxtcOh0W5ZNCvI48PeIOD4i2tJ7uZgupElY2oLPAj/NhksvBnYFfiDp8TLnqk8Nbehvi3V8LrBa1lXAaZI2ldQHuBC4PyLmlDdWojSN/AZAt+z+BtmtTfwSknQiaea2z0fEv8qdp5DS1OfHZ8NMUJr+/ArSB/KX69q3ldwKbE4aKjEW2Dtb/jnawHk62TS7/bLvtwT+D7g7It4ra7CPuhI4XNI22UQSk0g9Hm1i2l9J3UjDF9tU7xVAdp7VK8BxknpJ6iLpW6Shbm3iH02Stpa0YfZ+3gm4FLigXEMt6/m9fAMwXtJESV0lTQR2BH7fRvK9f5/0YbZrdr9VJ9SqK6OkjwFPAH+MiFNbM1cD8x0kabvsvbKBpCOBPYD720I+YBPSOX9js9tk0t+9L7dWvvoyStpD0hbZe7q3pLNIM5i22nNoRkT41kI30nkHF5OGmlSSptcdWO5cefkO44P/xOffRpU7W5YvgLWk8zbev5U7V16+TqSx8YuAlcBbwE3A5uXOVkveUdlzunG5s2R5HiUN21hJ6jW4BOhT7lxFcgo4B1hAOt/lEdLU/GXPluX7KmmIWO9yZ6kl38eBv2a/B5eRJmnYv9y58vIdCcwnXcbgVeCkMuep8/cy8AXgBWBV9vVzbSxfsXVntZWMwHXZ9ysKboe0kXzHZz+HK7Lfj/8GDm4rz1+RbR8FzmzNfA14Dk8G5mZ/WxYB9wE7tXZG39bvmyLaes+4mZmZmZlZ++AhgmZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZ2XpM0lmSHmzG/mdIuqeZGV6TdFhz2jAzM2srXGCZmbUSSZtJuk3SAkkrJL0h6U5J3cqdraki4qcRsW+5c5iZmbUVLrDMzFrP34D5wNZABbAzcD+gcoYyMzOz0nGBZWbWCiQNIBVWv4mIZZG8GRG/iYjV2TZjJD0mabGkJZL+LmnzvDaul/QHSddKWirpLUkTJY2V9IykSkmPSBqWt88cST+W9ETWazZZ0k515Owp6WJJsyW9K+k+SVvUsf2HhhhmxztD0kPZ8WZI2iVvfVdJl0halPXknVakzd2yvO9KmiXpe5KUrfuDpH9I6pTd313ScknbNfS1MDMza0kusMzMWkFEvAO8AFwj6RuStskVDfmbAWcBw4FRwArgxoJtvgzcAWwInAtcDZwDHAhslLVxdsE+xwAnZfvcDvxNUp9aol4NfAz4JDAEeBr4q6SujXi43wJOBPoCDwC/z1t3OrAPsAuwafY4R+ZWStqG1NN3ETAI+CJwPPD1vMeyMXCmpI2APwInRcTzjchnZmbWYlxgmZm1nt2BR4HvAs8BCyX9KFdoRcT0iHgkIlZHxDJSofRJST3z2ng4Iu6NiBrgBqAX8IesN6yKVECNLzju7yJiSkSsAS4EVpGKnA+RNBD4GnBcRCzMtj8bGAr8TyMe528j4oWIWAdcA2whqW+27hvAhRHxWkSsAk4lFYU5xwG3RcRdEbEuIl4GfpXtR0SsBA7O9nsAuC8irmtENjMzsxbVpdwBzMzWFxGxGDgDOCMrmr5C6jF6C7g2Gw54EamYqeCDwmMQMDf7fn5ee1VZbfb+MqAq2zffnLx9QtLrpF6gQptmX6cXdK51BTZp0IMsyAiszL5WAMuy4+bnWSlpUUGGPSR9KW9ZJ+CNvH1ekPQIsC9wQCNymZmZtTj3YJmZlUFEVEXE9cB0YGy2+DdAJbB9RPQBds2WN3cSjFG5b7LeshHAm0W2yxVxW0ZEv7xbz4j4YzMz5LxVkKcXqYDMz3BtwfH7RMS2efscShrCeDtpyKX/lpmZWZvhP0pmZq1AUn9JP5M0OpvooYukg4DRwOPZZn1IPT5Ls+F655To8N+StEN2HtUkoCdwb+FGEbEIuBm4UtLwLHc/SQdK6l2iLH8AJknaXFIP4Od8+G/RlcBXJe2b9zxtI+l/szwfB64ADgG+CQwknbdmZmbWJrjAMjNrHWuAwcCfgXeBt4EzgRMj4rZsm5OB3YDlpKLrryU69lXAZcASYALwxewcr2KOBGYCj0qqBJ4nnfMUtWzfWD8jTU3/FDAbeJ0Pes6IiBmk88O+SxpquAi4HhiUDau8DfhFRDyYncP1FeAkSZ8tUT4zM7NmUUSp/maamVlbI2kOcGZEFM5GaGZmZi3APVhmZmZmZmYl4gLLzMzMzMysRDxE0MzMzMzMrETcg2VmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZibjAMjMzMzMzKxEXWGZmZmZmZiXy/wE95yDwdcnyJAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'n_splits': 3,\n", + " 'gap_size': 1\n", + "}\n", + "\n", + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**test_size + n_splits + shift_size**" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", + "TEST INDICES: [8 9]\n", + "TRAIN LENGTH: 8\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", + "TEST GROUPS: [3 3]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", + "\n", + "TRAIN INDICES: [ 5 6 7 8 9 10 11]\n", + "TEST INDICES: [12 13 14 15]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 4\n", + "TRAIN GROUPS: [2 2 2 3 3 4 4]\n", + "TEST GROUPS: [5 5 5 5]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'n_splits': 2,\n", + " 'shift_size': 2\n", + "}\n", + "\n", + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**test_size + n_splits + expanding window**" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0]\n", + "TEST INDICES: [1 2 3 4 5 6 7 8 9]\n", + "TRAIN LENGTH: 1\n", + "TEST LENGTH: 9\n", + "TRAIN GROUPS: [0]\n", + "TEST GROUPS: [1 1 1 1 2 2 2 3 3]\n", + "TRAIN GROUP SIZE: 1\n", + "TEST GROUP SIZE: 3\n", + "TRAIN GROUP MONTHS: ['2021-01']\n", + "TEST GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", + " '2021-04' '2021-04']\n", + "\n", + "TRAIN INDICES: [0 1 2 3 4]\n", + "TEST INDICES: [ 5 6 7 8 9 10 11]\n", + "TRAIN LENGTH: 5\n", + "TEST LENGTH: 7\n", + "TRAIN GROUPS: [0 1 1 1 1]\n", + "TEST GROUPS: [2 2 2 3 3 4 4]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 3\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", + "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", + "TEST INDICES: [ 8 9 10 11 12 13 14 15]\n", + "TRAIN LENGTH: 8\n", + "TEST LENGTH: 8\n", + "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", + "TEST GROUPS: [3 3 4 4 5 5 5 5]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 3\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05' '2021-06' '2021-06' '2021-06'\n", + " '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 3,\n", + " 'n_splits': 3,\n", + " 'window_type': 'expanding'\n", + "}\n", + "\n", + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**test_size + train_size + n_splits (full usage of data)**" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4]\n", + "TEST INDICES: [ 5 6 7 8 9 10 11]\n", + "TRAIN LENGTH: 5\n", + "TEST LENGTH: 7\n", + "TRAIN GROUPS: [0 1 1 1 1]\n", + "TEST GROUPS: [2 2 2 3 3 4 4]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 3\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", + "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [1 2 3 4 5 6 7]\n", + "TEST INDICES: [ 8 9 10 11 12 13 14 15]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 8\n", + "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", + "TEST GROUPS: [3 3 4 4 5 5 5 5]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 3\n", + "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05' '2021-06' '2021-06' '2021-06'\n", + " '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 3,\n", + " 'train_size': 2,\n", + " 'n_splits': 2\n", + "}\n", + "\n", + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**test_size + train_size + n_splits (partial usage of data)**" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [1 2 3 4 5 6 7]\n", + "TEST INDICES: [ 8 9 10 11]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 4\n", + "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", + "TEST GROUPS: [3 3 4 4]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 2\n", + "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [5 6 7 8 9]\n", + "TEST INDICES: [10 11 12 13 14 15]\n", + "TRAIN LENGTH: 5\n", + "TEST LENGTH: 6\n", + "TRAIN GROUPS: [2 2 2 3 3]\n", + "TEST GROUPS: [4 4 5 5 5 5]\n", + "TRAIN GROUP SIZE: 2\n", + "TEST GROUP SIZE: 2\n", + "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "TEST GROUP MONTHS: ['2021-05' '2021-05' '2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA+oklEQVR4nO3dd5xU5d3+8c9FlbIUKYJKsaCJooCgiRqfGDXGXuJjkJgCdo0lGolGTexRoz9jYjRGjb08GkussUuiMZiACCKKQgRFmojAwiKw7Pf3xzmj47hldpnZ2V2u9+s1r5k59ZozW+Y7933uo4jAzMzMzMzM1l2rUgcwMzMzMzNrKVxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgLrDMzMzMzMwKxAWWmZmZmZlZgbjAMrMWT9Ihkp6R9LGk1ZI+lPSApH1KnS1D0kBJkccts9zJjZitk6SLJU2XtFLSAkl/l3R0AfcxS9JVhdpe1nYPlPRPSUskLZP0pqQbJHWu53ZGp8e9c/o88z4ckLXMzyXtXthXYGZmzU2bUgcwMysmSb8FTgXuAP4IfAwMAI4A/iZpy4iYWcKIGfOAnbOebw7cDfwEeK2a5d5rvGg8CAwDLgGmAr2B/wH2A/5coH0cSvLeFIykUcA9wJ9IsgewPfBjoBuwfB02n3kf3s6a9nPgD8C4ddiumZk1c/KFhs2spZJ0MPBXYExE3FbN/AOBiRExt5p5HSJiZdFD1kDSYOAN4FsRMa6EOQYB7wDfi4i/5MxTrOM/kWIeZ0n/BJZExP7VzKtXdkmjgVuBsoiotjCTtAj4Q0Rc0LDEZmbWEriLoJm1ZD8F/lNdcQUQEY9liqu0u9cZkq6R9BFJcYOknpJuT7sXVkgaJ2lE9naq67In6YL0A3fmeaaL2Y6SXkq72r0j6dD6vqjc/aWZHpA0RtJ7kpZLulNSe0k7Sfp3Om2cpP4529pA0m8kfSBplaTJkvbLWqRbej+/muP3hQJFUn9J/ydpcXqsnpa0ddb8TLe6IyXdIWkJ8Fg670tdBCXtlnZFrEiP/02SyrLmd5N0s6S5kj6V9L6km3Kyfyl3bvas9/53afYlkq6V1K66dXNeywGZ/EAP4Pys7py717S+mZm1XC6wzKxFktSGpAvXM/VYbSzQF/ghSbdCSFrAvgOcCYwk+bv5oqQtGxjtPuAR4LskRdxfJA1p4LayfZ2k69spJF3VvgdcC9wE/A74AUm3wxtz1nsAGA38GjgQ+A/wqKSh6fzpwArgGkl7S9qgup1L2hB4GdgaOCHdfyfgOUkdcha/CigHDk/3W932dgWeIymQ/pekWN6PpBUp42rgG8DpJO/ROSTdADNeA0ZJOlnSxtXtJ8vPgE2BI0m6Ex4HXFrHOtkOBZaSdJncOb29VusaZmbWIvkcLDNrqXoA7YEPsidKEtA6a9LarNaMeRExMmvZfYBdgd0j4u/ptBeAWSTF2PENyHVzRFyVbutpYBrwC5JzwtZFZ+DgiFiabnt34FjgmxHxj3TaxsB1kjpGRIWkPYH9yXp9wDOStgLOBQ6PiGWSjiUp1J4G1kgaD9yZvpbMsTudpKAaGhGL0/39k+RYHQVcl5V1fET8pI7XcznwSs778SHwvKTBETEV2Am4LiLuy1rvrqzH5wDbkRSa10p6j6Rg/k1E5LZslaevt4rk3Lz2wLmSLsu8ntpExCRJlcCciBhf1/JmZtZyuQXLzFq63PNsfgasybplf9B/MmfZnYCFWcUHEbECeJyk5aQhHs7aVhVJa9ZODdxWtgmZ4io1A1hN0qqUPQ0g05qzF0kL0T8ltcncgOeBz7pBRsS9JAODHAX8H7AVSUvYPVnb3gt4FliWtZ1yYGL2tlJP1PZCJHUkaQG6PyfXyyTv2fB00deBsZJOSovCL4iID9Jl9wL+H7CYpBCcImnTnMUfSd+PjIeADsDg2rKamZnlcoFlZi3Vx8Aqkm5f2e4EdkxvuRbkPO8LLKxhuQ0bmCt3ewvT/ayrJTnPVwPlOUXD6vQ+082vJ9CHLxaca4ALgH7ZG4uIjyPi1oj4UTrvVuCIrO6NPUm6UOZu61u52+LLxzlXd5JWxutztrUKaJu1vZNJWqR+BUyX9K6kL7QERsTaiHg+Is6MiBEkXQk3JCm0s1X3vkBh3hszM1uPuIugmbVIEVEp6V/A3iQfwDPTF5B+wE96C35xtZzn80iGJM+1EUlrSMYqIHdAhO41ROvNF4cj753upxQWAx8Ch9RnpYhYo2T4+zHAV4DJ6bYeBS6uZpXy3E3UsYsl6TIX8OVWRYC5aY4lJOfKnSppe5Jzz+6WNCUiptWQ/RlJk9Pc2XLf58zzUr03ZmbWTLkFy8xasmuAr0n6YQPXfxXoLel/MhPS7mv788Wud3OAr2Yt0wrYs4ZtHpqz3MHAvxuYb109T9KCtTwiJuTe0oxl1QxSATAovV+Qta1tgTer2db0+oRKu2GOB7auLld1w+pHxBSS8+JakRZPkr5UHKeDdGzKl1vRDk7fj4zvAitJrvuVr9V83jpoZmbrKbdgmVmLFRGPSLoGuE3St0iGBF9EMgDG3uliNV5sNiKelvQKcJ+ks0lans4kOTfnyqxFHwZ+ImkS8F/gGKBLDZs9RtJqkg/uxwBbAqMa9grX2bMkA1c8K+kK4E2S3EOBDSLiFySjAj4q6RbgFaAinX8uyTlQmULzapKRCl+QdC1Jy9hGwDeBl9PzuOrj5yQDWlSRjHRYDvQnKW7PjYh3JL1McuynkrR4HUsy4mGmYH1a0tsk7/sHJMXkySSti3/K2V8ZyYiON5EUir8kGUCjzgEusrwN7C/pKZKfq+kRkdt6Z2ZmLZwLLDNr0SLidEn/AE4iGUK7DPgI+BewX0T8rY5NHEIyQMI1JK0T/wb2iIgZWctcSNKl7BKSVow/kBQr1Y2UdwTw23TZD4CRETGpIa9tXUVESPouyWh7PyUpYBaTFE7XpovNBG4mOXfpRJLi8n3gFuCKiKhMt7VI0tdJhjb/Lck1qOaRFGBTGpDt5bTl8EKS8+ZaA7OBp/i89elfJEPMDwTWApOAfSNiTjr/NyTH+wqS9+cjkqHTvxERua2G/49kGPt7SVrB/pwel/oYSzJa4hNAR5Lzz8bVcxtmZtbMqR4XsjczswaSNJpkYIiyiKix1cwan6QATomIP5Q6i5mZNX8+B8vMzMzMzKxAXGCZmZmZmZkViLsImpmZmZmZFYhbsMzMzMzMzArEBZaZmZmZmVmBuMAya4YkDZU0XtIKSbfmzAtJu6eP20m6QNLQImQoyrYljZP0QIG3uXs6Ulx919tL0n2SZkuqkDRV0smSWq9rBklbpcevW323Vcd+Zkm6qpDbzGOft0maUOBtDkx/lgfWc70dJd0qaUb6nk2XdH56geFGydAY0p+dRVnPd0+zDk6fN+j3s9jHXdIhktakv1Nn12cfZmbNha+DZdY8XQJsAhwJvFHLcu2A84FZJNc2KqRibfskYE0Bt7cujiO5ntF5JNes+gbJ9ZI2A362jtveiuT43QYsWcdtZTuU5ILIjelikutjNQUjgS1Irn31LrA9Sb7tgcNKmKvYXgN2JrluGRT3d786+R73vwPfBo4GLpN0b0TMboR8ZmaNxgWWWfO0FfB4RPy11EEKLSKmlTpDlpMiYlHW83GSOgKnSzonIlY1RghJG0TEp/ksW4qLFkfEzLqXajSXV/OefQr8SdKAlvphPiKWAeNLGCGv4x4Rn6TzFgE/ALYmuYC0mVmL4S6CZs1TO2BFHsuVp/e3pt1+Puv6I2kDSb+R9IGkVZImS9ove2VJB0mamHZF/ETSq5K+Wde2ayNpW0lPSVqcbvctST/Jmv+FLoJZ2869jc5aZjdJf0+7Jn0s6SZJZXkcn1rlfGDMmARsAGzY0O2mXTgfS5++l76eWem80enzndJjsRIYm867XNIbkpZLmiPpbkl9crb9hS6Cme57kr4taUp6zF+WtG098m4q6X5JCyWtlDRT0sW5+8jJUN17dkHWMoMlPSGpPL39Jfe1NEQt7xnAxuuy7azuc9+T9CdJS9P34UJJef8/lXS0pGnpsVyU/uxum7OP70u6Mz02CyWdX8c2v9BFkNp/93+hpCvfp5IWpL+P63TsG3DcMxfbbrcu+zUza4rcgmXWwkSEsp7uAbxA0qXwiXTavPT+AWAnkm5EM4HvAY9KGhERr0vaIl3mdyQf8DcAhvN5YVHbtmvzGPAWybfXq0i+we5Sy/I75zz/PnAyMANA0q7Ac8Bfgf8FegCXA93T50TEOCD7uJAWNOMiYnQemXPzLAEW1melnAyvAWcCVwHfJTluua1h9wLXAxfyeRfC3sCvgblAL5Juii9IGhwRVbXsvj9wJXApsDLd732Stov8rtVxB0kXwOPSLJsDX6ll+UOB9lnPv5XmfgdA0pbAP4EJJD8HbUi6kz0maadIzOLL79k4gIjYPY/M2XYGqvi8+1xeqsuQ+g3wIMnP157Ar4A3gfvr2qak/wFuSNf5F8nP/s5A15xFrwQeT/fxP8D5khZFxHV5xq/291PSj4BzgLPSzD3SZTtB9a+5sY+7mVlz5wLLrHnqRn4tWP9J72dGxGfdhyTtCewP7B4Rf08nPyNpK+Bc4HBgGFAeEWOztvdkXduujaSeJOcvHRwRmXPHnq9tnZzcw4FjgQsj4uV08uXAKxExMmu5D4Hn08Jjag2brgTW5pM7a7vbACcCV0REvdbNFhHLJE1Pn05KP9Tm+n1E/C5nvaOysrQm+YA+h+TcsH/UsssNgV0j4t103VbAwyTF7dt5RN4JGBURmVa3cbUtnN1NUdIA4Azgtoi4J518PjAf2DciVqfLTUmz7MfnBUGueh/ztGXmPODOiKhXUVyLf0RE5hy8ZyXtQ1Io11lgkRzLKRFxWda0R6tZ7s2IOD59/LSk3sA5kv5YRzGdUdPv/k7AMxFxfdayD9WxrWIc94r0PrewNDNr9txF0KwZkdRJ0lEkH0omrsOm9iL5gPtPSW0yN5JiZ0S6zBtAV0m3S9pbUqd1Cp9YTDJYxA2SRqYfGvMiqRfJB8HngIvSaR1JviW/P+d1vEwyUMbwmrYXEVtGxNH12H93klaLKSStMcX2pSJD0r6SXpG0lKRAnJPO2qqObc3KFFepzHlum+aZ5XWSAQlGS+qf5zpI6kBSyM0mKUwz9kqnV2W9Z++RDMgwInc7GRGxZ0TsWY/9tyMpepYDp+e7Xh6eyXk+jfody2GSfivpf9KM1Xk45/lDJF3t8t1PbfvfL+3WuJPyGBGzSMf9I+B9YLSkjevTxdLMrKnzHzSzZiI9f2I58Gfg2oio7lvvfPUE+pAUIdm3C4B+ABExHTiYpDvYk8AiSfekhU6DpN+8701S3N0CzJf0kqRhta2XfgC/H1gN/CCrW1t3oDVJV7rs17EKaJt5LetKyVDTj5B0ezso0+pSZAtyMuxI0tIxB/ghSWH59XR2XUOQL8l5nsmf79DlI0m68/0WmC3p9bQVtC43krwHh+UM0tGTpIta7s/f5hTuPRNJ18Ztgf3SwRUKZUnO89XkeSwj4jlgDEm3v3Ekv1fXVfMFRm6rT+Z533ol/bJbSLoIfg94FVgg6ZJ8Cq185Hvc09/h7wE7AB+SdJk0M2sR3EXQrPmYC+xG8qHkJEl3R8SrDdzWYpIPNYfUtlBEPAE8IakrSZfCa4BrgSMauF8i4m3gMEltSV7PFek+Nq2l69NVwI7A1yNiadb0JUCQFIZPfnk15jY0Z0b6wfMeYBuSbnYL6lilUHLPjTqU5Fv/kZkCM+1+V/wgER+StDS0IunidgHJ+Xr9I6LaIeEl/RQYBexTzch9i0laaG6uZtXqBktoiGtIviD4dvoz12RExO3A7emXFd8lKVzLgezrQuW27mae53OeY237rkr391tJ/Ugu9XApSeF+w7psO3UN+R/335F82fIjPh8Qw8ys2XOBZdZMpK0mL0saT3INmb1JvoGuTU0tFc+TDJCwPJ8Pn2lRc4+SEQQzg07UtxUkd5trSAZouJqkgOlG8sH7CyT9EDgNOCL3fKqIWJEej60j4qKG5MjD9cA+wF5pq16h1Pf4dQDW5AxKcWQB89Qp/XA+XtKFwCvAAKq55pakb5EM0nBO2mKT63mSFo6JeQ6yUS+SfkEyEMr3ss7Va3Ii4iOSYcy/S1LAZzsU+GPW88xgKHPIT50/XxHxAXC5pDHV7L/e6nPc0y63XwOOSb/IMTNrMVxgmTUzEVGp5BoytY28l1l2taT3gO9Jmgp8SnIO0bPA0yQn6F9BMppYF2AosEFE/ELS8STF1FMkLUGDSAa/uKO2bdfWfU7S9qQj2AH/JenidxYwOSKqK662IOlm9jeSrmlfz5o9M/2A+nOSAS2qSEY9LCcZNW9/4NyIeKeGLDOAv9d2Hpakc0hGzruM5Hyh7P1PS689hJLhx8/PGcGxLpli7XhJ/wdUZA38UZ1ngZ9KuoZkJMZdSEbgK6q09fJpkvf9HZJukj8jaXl4q4bl7wemAv/IOWZzImIOSQvYv0laLm8habXahOQCtLelIy5Wl+V5SM4JqiXv90nOkbsN+LCGnxmUDPN/K7BZDYOMFEVanG5I2j2QZDCZb/LF1iuAbSX9ieS8v/8h+VLltDwHuKjtd/9aki8yxgNLSUZ4HETye1hT5oId9yyZv1+FGnjEzKzJcIFl1jwF1Q8fXZ0TSIqa50g+HG8WEbPSb83PAX5KUpAsJjkB/tp0vSnAQcDVJB8I5wE38cVzJb60bZKBCmoyn+TconNJTthfArxIzR/u+pF8A79vess2huTD+MtKhr6+ELiT5Jys2SSFYW3d+dqky9Zm7/T+F+kt27f4fDS9jiTd9/IWEbMlnQmcCpxC0jIxsJbln5R0VrrssSQjCB5AOvR5EX1KMuDJaSTvRwXJh/O9I2JlNct3JznHqmeaMduFwAUR8U76AfwSkgK6A0mX1edJh9+vQT7nCWXes9HpLdsYkgIAkvdsNV8+n6rY/kMy8MMRQBnJz+oFJN3lsv2c5P19kOQ9uBj4Qz33Vd3v579Ifn6OJ/ndmgEcG7VftLyQxz0j8/er4C2YZmalpiL0zjCzIpM0E3gyIk4pdRYDSX8HXoiIC0udxfIj6XagKiLGlDpLtnQwm/eAAyPi8RLHKRpJmUsE7BsRT5U6j5lZIbkFy6x5mgN8Q9LGwPx8uw1Z4aUjHA4mvaixNRs7A4eVOsT6Jh1lsCPJOWaQ/zllZs3CxIkT27Vq1erE1q1bj4mIruTf28Sah5C0dO3atbdWVVX9cfjw4dWeFuECy6x5uhq4m6Rb1e18uUtOSaSjzNV4+YeIqGzEOI0ifU09Sp2joep6z4C1xRiIotQioq5rhzVIWnDXstuGX6C6hTiYz6/x9WAtFwI3a5batGlzU5cuXXbdeOONV7Rr1+7j5DsFaykigtWrV7edO3fuKcuWLdsB+HF1y/k6WGbNUEQ8QnKOy2CS8zeailv48rWNPrul3Z+safkVtbxnJAMwWP5qO5bP17VyRMyKCLXg7oHjSAb22Cgi3OprLdE3BgwYsLR9+/ZrXFy1PJJo3779mgEDBiwFvlHTcm7BMmum0gu3vlnqHDkuoPYT8df5ulRWcDcCtX2YL+TQ9OuDHWuZV95oKZqoiFhCMpiOWUvVulWrVi2u1d++KH2PaxwAyINcVKNnz54xcODAUscwMzMzsxKaOHHioojole/ykydPnjVkyJBCXTDdmrDJkyf3HDJkyMDq5rkFqxoDBw5kwoQJpY5hZmZmZiUkaXapM1jz4wLLzMzMzKyIfn3v6iEVq4r/ubtjeyrPGdVucrH3k+uPf/zjhtdcc02f6dOnTyvG8s2NB7kwMzMzMyuixiiu6rOfjh07Dsvc2rRps0ObNm12yJ5W3/2eeOKJi+tTLNV3+cY0ffr0dpKGz5w5s21Dt+EWLDMzMzOz9UhFRcWkzOORI0cOqKys1IMPPjirumVXrVql9u3be9CGenALlpmZmZmZAbDTTjttfdRRR/Xba6+9tujcufOwCy+8cKOZM2e23W233QZ17959SFlZ2dDhw4dv/dJLL3XMrPP73/++R//+/Qdnb+PYY4/d9Dvf+c4WnTp1GtavX7/Bd911V7eGLl9VVcXZZ5/dZ6ONNtq+a9euQ48++uh+O++881ZnnHHGxtW9hpUrV2rUqFEDNtxwwyGdO3ceNmDAgMG33HJL98z8p556qvPw4cO37tq169B+/foNPv/88zeqqqoCYMSIEdsADB48eHDHjh2HjR07tm99j6ELLDMzMzMz+8z999/f89RTT124bNmySb/4xS8WVlVV6YQTTlj4/vvvvzFv3rzJ22+/fcXIkSO3WLVqVY0X+3rggQd6nHnmmfOXLVs26Zhjjll44oknDiwvL6+x9qht+euvv77HTTfdtNFDDz307sKFCyf37dt39X/+85/ONW3ruuuu6/H66693mjZt2tTly5dPev7556cPGTJkJcDEiRM3OOywwwadfvrpCz7++OPXH3300Rk333xz7+uvv74HwIQJE6YBTJ06dWpFRcWkK6+8cl59j58LLDMzMzMz+8y+++77yUEHHVTeqlUrysrKqgYNGrT6yCOPXFpWVlbVuXPnuPrqqz+cN29eu6lTp7avaRsHHHDAJ9/+9rdXtG7dmtNPP33R8uXLWzd0+XvuuafHD3/4w4923XXXle3bt4+LLrpoQe/evdfUtK127dpFRUVFq9dff73DmjVr2HLLLdcMHz78U4Df/e53vffbb79PfvCDHyxp06YNw4YN+/SYY45ZeM899/RYl2OWzedgmZmZmZnZZwYMGLAq+/m8efPanHTSSZuOHz++rLy8vI2kAJg/f36NtUTfvn0/K4C6dOlSBbBs2bIaL85b2/Lz589vO2DAgNWZ+a1ataJv376rv7yVxIknnvjxggUL2p555pn9Zs+e3X7nnXcuv/rqq+cMHjx41fvvv99u/PjxXcrKyrpllo8I9enTp8bt1ZdbsMzMzMzM7DOtWn2xRDj99NM3WbBgQdvx48e/vXz58knvv//+FEgKk8bI06dPnzWzZ89ul3leVVXFvHnz2tW0fNu2bbn00kvnT5069a333nvvjQ4dOlSNHj16IMCmm266+vDDD19UXl7+eua2fPnySTNmzHgTvvzaG8IFlpmZmZmZ1ai8vLx1hw4dqnr16lW5dOnSVqeccsqmjbn/UaNGfXzXXXf1euWVVzqsWrVKF1544UYLFy6scRj1Rx99tOyll17quGrVKnXq1KmqU6dOVa1btw6A0047beFjjz224T333NN11apVWrNmDRMnTtzgiSee6AxJS1qrVq2YNm3aBg3N6wLLzMzMzKyIOransjnv59e//vWHH3/8cdsePXoM3XbbbbfdZZddlrduXWNvv4L7yU9+8vGYMWMWHnLIIYN69+49ZM6cOe2GDBmyon379lXVLT9v3ry2o0eP3qx79+5D+/TpM+SDDz5od/PNN88G2HHHHT994IEH3r322ms36tOnz/Y9e/YcOnr06M0yBVvnzp1j7NixH44ZM2bzsrKyoWeddVaf+uZVhIe1zzVixIiYMGFCqWOYmZmZWQlJmhgRI/JdfvLkybOGDBmyqJiZDNauXUvfvn23v+iii+accMIJi0uRYfLkyT2HDBkysLp5bsEyMzMzM7Mm7cYbb+xeUVGh8vLyVmecccbGn376aavDDjtsaalzVccFlpmZmZmZNWl/+tOfem+00UZDNt544+1feumlLg899NC7vXr1WlvqXNXxMO1mZmZmZtakTZw4cXqpM+TLLVhmZmZmZmYF4gLLzMzMzMysQFxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgHkXQzMzMzKyIllx95pBYuaLon7vVoVNltzOumlzs/dTHlltuue1ZZ50199hjj/2k1FkaiwssMzMzM7Miaoziqj776dix47DM49WrVwugXbt2kZlWUVExqb77nj59eruvfOUr282YMWPKFltssSYzfcaMGW/Wd1uN5bDDDhvYpk2buO+++2YXcrsusMzMzMzM1iPZBdTIkSMHVFZW6sEHH5xVwkgtis/BMjMzMzMzAN599912++yzz+Y9e/Yc0qtXr+1HjRo14JNPPmkFUFVVxSmnnLJJ7969t+/UqdOwTTbZZLtLL720N8CIESO2ARg8ePDgjh07Dhs7dmxfgE022WS766+/fkOAxx9/vKxNmzbDb7rppu79+vUbXFZWNnS//fbbPLN9gClTprTfcccdt+7cufOwrbfeepuLL764t6ThNeX961//WvbVr351m86dOw/r3r37kF122WWrzLzy8vJWxx133KabbLLJdl27dh262267DZo6dWp7gPPOO2+jRx55ZMMHH3ywR8eOHYd17NhxWGVlZUGOoQssMzMzMzOjoqJCe+6551Zf+cpXPp01a9aUadOmvTl37ty2xx13XH+Av/71r13uv//+Hq+88spbK1asmPTvf//7rd13370cYMKECdMApk6dOrWiomLSlVdeOa+6faxdu5Znn322y9SpU6dNmzZt6ptvvtnx8ssv7w2wZs0aDjrooEHbbrttxfz5819/+OGHZ9xxxx29ast83HHHbXbCCScsWLZs2aS5c+dOOeeccz7b75FHHjng3Xff3WD8+PFvLViwYPKIESNWHHjggVuuWrVKl1xyyYKDDz548WGHHfZxRUXFpIqKiklt2hSmc58LLDMzMzMz47777usWEVxzzTVzO3fuHL169Vp7ySWXzH3kkUc2rKyspF27drF69Wq9/vrrHSoqKrTJJptU7rrrrivru59rrrnmw65du1b169evcp999lny2muvdQJ44YUXOs+dO7fdH/7whzmdO3eObbbZZvVJJ520oLZttW3bNmbOnNl+zpw5bTp06BAHHHBAOcC8efPaPPbYYxveeOON7/fr169ygw02iKuuumruokWL2o4bN65Tw45QflxgmZmZmZkZ//3vf9vNmzevXVlZ2dDMbb/99ttKEh988EHbAw44oPzcc8/98LLLLuvbu3fvobvuuuugf/zjHx3rs4/WrVuz8cYbf9YXr1OnTlUrVqxoDfD++++33XDDDSs7d+782YAbm2222aratvfAAw/MmDlz5gZDhgzZdostttj2oosu6g3wzjvvtAPYYYcdtsm8lm7dug2trKzUrFmz2tUnc315kAszMzMzM2PAgAGrBw4cuKq2kf/OPPPMRWeeeeai8vLyVmPHjt145MiRW8ybN++NVq3Wvd2mf//+az755JM2y5cvV6bIqqsY2nnnnVc+8cQT/62qquKZZ57pfMghh2w1dOjQlcOHD18JMH369KnZBV22QmSudrtF2aqZmZmZmTUrI0eOXLpmzRqdffbZfT755JNWVVVVvPfee23vuOOObgAvvvhix6eeeqrzypUr1aFDh6qysrK1mSKlb9++a1q1asW0adM2aOj+99hjj+V9+/Zdfeqpp25aUVGht99+u93111+/UU3Lf/rpp7r22mt7zJs3r02rVq3o0aNHpaRo3bp1bLLJJpUHHnjg4qOPPrr/e++91xZg0aJFre+4445uS5cubQWw0UYbrZk9e3b7tWvXNjRytVxgmZmZmZkVkTp0KszwdEXeT1lZWdXzzz8//a233uqw9dZbD+7SpcuwPfbYY6tJkyZ1BCgvL299xhln9OvZs+fQ7t27D33hhRe63HXXXTMBOnfuHGPHjv1wzJgxm5eVlQ0966yz+tR3/23btuXhhx+eMWXKlI69evUaevDBB285cuTIj9u2bRs1rfPAAw9032abbbbt2LHjsEMPPXTQ2LFj5+6///7LAe6+++7ZgwYN+nT33XffulOnTsMGDx687V/+8pfukgA46aSTPqqoqGjVvXv3oWVlZUMLNYqgImrMu94aMWJETJgwodQxzMzMzKyEJE2MiBH5Lj958uRZQ4YMWVTMTOubK6+8sud1113XZ9asWVNLnSXb5MmTew4ZMmRgdfPcgmVmZmZmZk3C008/3fnNN99sX1VVxauvvtrh97//fZ9DDz10calz1YcHuTAzMzMzsyZh1qxZ7UaPHr3ZkiVL2nTv3r3ygAMO+OTSSy+t9ppaTZULLDMzMzMzaxKOP/74xccff3yzarHK5QJrPXHxvQ0/ae+Xoxrnx6ShGZ0v0dTzQdPP6HzrZtnVP23wul3OuKZgOWrT0IzOl2jq+czMmgKfg2VmZmZmVhhVVVVVKnUIK670Pa6qaX6LL7AktZZ0paSPJJVLelBSz1LnMjMzM7OWRdL8lStXNvg6UNY8rFy5cgNJ82ua3+ILLOBs4GDga8Cm6bQ7SxfHzMzMzFqiysrKC2fNmtVuxYoVHdyS1fJUVVVpxYoVHWbNmtWusrLywpqWWx/OwToOuCgi/gsg6efADEkDImJ2aaOZmZmZWUuxww47PP3aa6+dPHPmzPMjog/rR2PG+qRK0vzKysoLd9hhh6drWqhFF1iSugH9gYmZaRExU9IyYAgwO2vZ40iKMfr379+4Qc3MzMysRUg/eNf44dtavpZeVZel90tzpi8BumRPiIgbI2JERIzo1atXY2QzMzMzM7MWpqUXWOXpfdec6d2AZY0bxczMzMzMWroWXWBFxBLgfWCHzDRJm5O0Xk0pUSwzMzMzM2uhWnSBlboROEvSZpK6AFcAT0fErNLGMjMzMzOzlkYRUeoMRSWpNUlRNRpoDzwLHBcRi2paZ8SIETFhwoTGCWhmZmZmTZKkiRExotQ5rHlp0aMIAkTEWuDM9GZmZmZmZlY060MXQTMzMzMzs0bhAsvMzMzMzKxAXGCZmZmZmZkViAssMzMzMzOzAnGBZWZmZmZmViAusMzMzMzMzArEBZaZmZmZmVmBuMAyMzMzMzMrEBdYZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIG3yWUiSgCOAEUBZ9ryIOK4IuczMzMzMzJqdfFuw/gj8AegHtM25mZmZmZmZGXm2YAGHAztFxMxihjEzMzMzM2vO8m3BqgDeL2YQMzMzMzOz5i7fAus3wK/Sc7HMzMzMzMysGvl2ETwVGACcImlh9oyI2KrgqczMzMzMzJqhfAusS4qawszMzMzMrAXIq8CKiNuLHcTMzMzMzKy5y7cFC0k7AkeRDNX+AXBLRPynWMHMzMzMzMyam7wGuZB0CPAPoCswCegC/F3SocWLZmZmZmZm1rzk24J1PnBYRDyZmSBpX+By4OFiBDMzMzMzM2tu8h2mfSDwVM60p0lGFjQzMzMzMzPyL7BmA3vlTNsTX3zYzMzMzMzsM/l2EbwYeETSA8B7JC1ahwE/LlIuMzMzMzOzZievFqyIeJCkxaoCGAGsBL4dEQ8UMZuZmZmZmVmzkvcw7RHxCvBKEbOYmZmZmZk1azUWWJK+FhGvpo93qWm5tPAyMzMzMzNb79XWgvUcUJY+frmGZQJoXdBEZmZmZmZmzVSNBVZElGU9zne0QTMzMzMzs/VWXoWTpB/WMP3IwsYxMzMzMzNrvvJtmbquhunXFiqImZmZmZlZc5dvgaUvTZAGApUFTWNmZmZmZtaM1TpMu6Q1pANZSFqdM7s18MdiBTMzMzMzM2tu6roO1l4krVdPAvtmTa8C5kfEu8UKZmZmZmZm1tzUWmBFxN8BJG0REfMaJ5KZmZmZmVnzVFcLFgARMU9SD2BHoBdZ52RFxB1FymZmZmZmZtas5FVgSdoLeBBYDXQDlqT37wEusMzMzMzMzMh/FMHLgYsiohewPL2/GLihaMnMzMzMzMyamXwLrEHANenjTPfAK4CfFjiPmZmZmZlZs5VvgVUBtE8ffyypP9AO6F6UVGZmZmZmZs1QvgXWK8Ah6eO/AY8CzwH/KkImMzMzMzOzZimvQS6AH/B5MXYm8DOgDLi6GKHMzMzMzMyaozoLLEltgKtIiioi4lPg0iLnMrMW6OJ7Kxu03i9H5ftd0LpxvnXT0HzQ9DM2Vr5lV/+0Qet1OeOaguaoSUvNB00/o/Mlmno+M8iji2BEVAJHAKuKH8fMzMzMzKz5yvccrEeBw4oZpBgkHSHpJUnLJDX8q1UzMzMzM7M85NvnoS1wl6QTgFlAVWZGRBxXhFyF8glwPdABuLHEWczMzMzMrIXLt8BaA9ybPm6d3pq8iHgaQNLupU1iZmZmZmbrg7wKrIgYU+wgpSbpOOA4gP79+5c4jZmZmZmZNUf5noOFpK6Svi/p5+nzPpI2Ll60xhURN0bEiIgY0atXr1LHMTMzMzOzZiivAkvScGAGcDbwy3Ty9sC1RcplZmZmZmbW7OTbgnUN8POI2B7IjMb3CvD1YoQyMzMzMzNrjvId5GJb4Lb0cQBExHJJnYoRqlAktSYZAbFd+nyDdNaqiIiSBTMzMzMzsxZJ+dQZkqYDe0fEbEmLI2JDSVsCj0TEtkVP2UCSRgO3VjNrs4iYVdN6I0aMiAkTJhQrlpmZmZk1A5ImRsSIUuew5iXfLoK3A/8n6RuA0nOybgZuKlqyAoiI2yJC1dxmlTqbmZmZmZm1PPl2EbwC6AQ8CXQGXgR+hwe5MDMzMzMz+0y+18FaC5wLnCupZ0QsKm4sMzMzMzOz5iffYdqfyjzOLq4kPVGMUGZmZmZmZs1Rvudg7VLDdA/TbmZmZmZmlqq1i6Ck72eWkzQKUNbsQcAnxQpmZmZmZmbW3NR1Dtal6X174NdZ06uA+cApxQhlZmZmZmbWHNVaYEXEZgCSHo2IgxonkpmZmZmZWfOU1zlYLq7MzMzMzMzqVmMLlqTfR8Sp6eMba1ouIo4rRjAzMzMzM7PmprYugm1reGxmZmZmZmbVqLHAiogTsx6PaZw4ZmZmZmZmzVe+18EyMzMzMzOzOrjAMjMzMzMzKxAXWGZmZmZmZgXiAsvMzMzMzKxAai2wJD0qaT9JaqxAZmZmZmZmzVVdLVgfA/cDsyT9UtLGjZDJzMzMzMysWaq1wEqHZ98Y+A3wXZJC6xFJ+7pVy8zMzMzM7IvqPAcrIpZFxHURMQzYDVhE0qr1nqTzih3QzMzMzMysuajXIBcR8WpEHE1SaK0FLixKKjMzMzMzs2Yo7wJLUhtJh0t6FpgAzAF+WLRkZmZmZmZmzUybuhaQtBVwLPCjdPnbgVMi4u0iZzMzMzMzM2tWai2wJP0d+AbwT+BnwF8iYlVjBDMzMzMzM2tu6mrBmgScEBFvNUYYMzMzMzOz5qyuc7AuB7arboak70nqXfhIZmZmZmZmzVNdBdbPgUE1zNscOKuwcczMzMzMzJqvugqs/YCba5h3K3BAYeOYmZmZmZk1X3UVWH0iYkF1M9LpfQofyczMzMzMrHmqq8BaLalvdTPS6WsKH8nMzMzMzKx5qqvA+idwSg3zfgK8VNg4ZmZmZmZmzVddw7RfCrwkqRdwL/AhsAkwCjiS5BpZZmZmZmZmRh0FVkRMkHQQcB1wNBCAgBnAQRHxWvEjmpmZmZmZNQ91tWAREc8CW0kaBPQCPoqId4uezMzMzMzMrJmps8DKSIsqF1ZmZmZmZmY1qGuQCzMzMzMzM8uTCywzMzMzM7MCcYFlZmZmZmZWIC6wzMzMzMzMCsQFlpmZmZmZWYG4wDIzMzMzMysQF1hmZmZmZmYF4gLLzMzMzMysQFxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgbUodoKUYePYTDVpv1uX7FzhJ9ba7fbsGr/vGj98oYJKaNTSj8yWaej6A6054oUHr/eSGPQqcpHrOt27mnP1Sg9fd9PLdCpikZg3N2Fj5nn9hiwatt+ceMwucpHpNPd+t785t8LpjBm1cwCQ1a2hG50s09Xxm4BYsMzMzMzOzgnGBZWZmZmZmViBNssCS1LbUGczMzMzMzOqr0QosSX0kPSZpqaR3JB0tKSQNlHSbpLvT+8XA79N1TpQ0PV1nvKTdsrZ3gaTncvYxTtJ56ePdJVVK+rGk2ZIWp9vv3Fiv2czMzMzM1i+N2YJ1N7Aa6Ad8A/hhzvzDgb8BvYCfSRoFXAz8COgB3AQ8JWlAPfbZGjgQ2B74KrAVcHV1C0o6TtIESRM++uijeuzCzMzMzMws0SgFlqRNgT2AsRGxLCIWkhRP2V6OiPsiYm1EVABjgD9FxKsRURkRfwamAN+v5+7PioilEbEA+BXwI0lfet0RcWNEjIiIEb169ar3azQzMzMzM2usFqxN0vv3s6bNzllmVs7zfsB7OdNmptPrI3s/s4D2QM96bsPMzMzMzKxOjVVgfZje98+a1j9nmaqc5x8AA3OmbZ5OBygHOuXMr+4iB9ldCgcCq4BFNUc1MzMzMzNrmEYpsCJiDjAOuFxSmaRewHl1rHYbcLyknSS1kTQGGArck86fCOwgaXg6/2Rgs2q2c5mkLpJ6AxcAd0ZEbjFnZmZmZma2zhQRjbMjqS/JQBW7AQuA3wLXk7Q6XQZURsQxOeucDJwKbARMB34eEeOy5l8GZNa5Id32cxFxiaTdgeeAo4GLgC7AY8BPIqK8tqwjRoyICRMmrMOrNTMzM7PmTtLEiBhR6hzWvDRagfWlHUvfAR4BOkQRQmQKrIhoU991XWCZmZmZmQssa4h6Fx8NJWkoyXlWb5B05bsEuK8YxZWZmZmZmVkpNOZ1sLoDDwHLgZdJhlw/rRH3b2ZmZmZmVlSN1oIVES8CWzbi/sbRiK/PzMzMzMysMVuwzMzMzMzMWjQXWGZmZmZmZgXiAsvMzMzMzKxAXGCZmZmZmZkViAssMzMzMzOzAnGBZWZmZmZmViAusMzMzMzMzArEBZaZmZmZmVmBuMAyMzMzMzMrEBdYZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIC6wzMzMzMzMCsQFlpmZmZmZWYG4wDIzMzMzMysQF1hmZmZmZmYF4gLLzMzMzMysQFxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgLrDMzMzMzMwKxAWWmZmZmZlZgbjAMjMzMzMzKxAXWGZmZmZmZgXiAsvMzMzMzKxAXGCZmZmZmZkViAssMzMzMzOzAnGBZWZmZmZmViCKiFJnaHIkfQTMLuAmewKLCri9Qmvq+aDpZ3S+ddfUMzrfumnq+aDpZ3S+ddfUMzrfuilGvgER0avA27QWzgVWI5A0ISJGlDpHTZp6Pmj6GZ1v3TX1jM63bpp6Pmj6GZ1v3TX1jM63bpp6Plt/uIugmZmZmZlZgbjAMjMzMzMzKxAXWI3jxlIHqENTzwdNP6PzrbumntH51k1TzwdNP6PzrbumntH51k1Tz2frCZ+DZWZmZmZmViBuwTIzMzMzMysQF1hmZmZmZmYF4gLLzMzMzMysQFxgFZGk1pKulPSRpHJJD0rqWepcGZKOkPSSpGWSKkudJ5ekKyS9meabK+kmSRuWOlc2SZdKei/NuFDSA5L6lzpXLkmtJL0iKSRtWuo8AJJuk7RG0vKs20mlzlUdSXtJGp9mXCTp+lJnAkh/P7KP38r0Pd6h1NkyJPWRdF/6d/ATSS9IGlLqXBmSeki6XdJ8SUsl3SOpewnz1Pp3WdI+6fu+UtJUSXs3lXySNpH0iKTZ6c/hDxozW54Z90t/BhelP48vSdqtCeXbTdJrkhanP4+vSfpuU8mXs9yJ6ft8XmPmS/dd2zHcPc2V/bfxlcbOaOs3F1jFdTZwMPA1IPOh9s7SxfmST4DrgZ+WOEdN1gI/AHoAQ0iO4W2lDFSNO4GhEdEFGAi8D/xfSRNV73SgotQhqnF7RHTOujWJwiWbpN2BB4CrSH4WNwVuLmGkz0TEttnHD7gamBYRr5U6W5brgQ2BrYCNgAnA45JU0lSfuwPoDAwCNiN5j0v5d7rGv8uSNgceAi4Duqb3D0sa2BTyAVXAM8D3gTmNmClXbRm7A9cCWwK9gHuAv0nq12jpas83HTiU5OewW7rMXZK+2kjZII/PBpIGAD8D3mikTLnqyrg253/LLo0XzQzalDpAC3cccFFE/BdA0s+BGZIGRMTs0kaDiHgaPvsA2eRExDlZTz+S9Dvg/lLlqU5EvJ31VCQfMLYuUZxqSdoKOAk4DJhU4jjN0WXADRHxQNa0plTAACCpDXAUSd6mZEvgDxHxCYCkPwNjST5ALiplMEmdgH2BYRFRnk77NTBOUv+IeL+xM9Xxd/nHwMSIuCt9frekE9LpF5Y6X0TMA65L569tjDzVqSPj3TmT/ijpfGBH4IOih6POfAszjyW1Ivmf0ork9+itUufL8mfgXODERoj0JU3984uZW7CKRFI3oD8wMTMtImYCy0haY6z+9gQmlzpELknfl7QUWA6cBlxQ2kSfS/9B3wKcCSwpbZpqHZZ2hXlHSXfazqUOlC39AL4T0CbtqrNI0jhJI0qdrRqHkLRq3FHiHLmuJHmfe0nagOSLp5cjoqTFVUpZt4zM/8WhjZ6mbkPI+p+Seg3/T2kwSdsBPSldS0y1JC0BVgEvAa+StAw2CZKOB1ZExH2lzlKL1pI+SLv+PtGUuiXb+sEFVvGUpfdLc6YvAbo0bpTmT9JhwAkkBUyTEhH3RERXoC9JcdWU/lGfBsyPiIdLHaQa1wJfIflwcyjwTeCmkib6su4kfydHAaOBjUk+6DyZfonSlBwP3BcRS0odJMc/gdbAQpIvIb4LHFvSRKmIWA6MAy6Q1E1SLyDTct4U/06X4f8pBSOpN/AgcFVEvFvqPNkiohtJ19VDgSeBJnGetJJzjM8j6RXRVL1N8gXJZiT/Y6YAL0jauJShbP3iAqt4ytP7rjnTu5G0YlmeJB1O8sH7oCZ2bskXRMR8kpyPqwkMxiFpS5I+8ieXOkt1ImJiRCyIiKqIeJPkPLH/ldS+1NmyZH6Pb42IKRGxmqQLXlugyfTpl7QFSQvvDaXOki1tQX0OeIfkb2FH4FLgJUkblTJblh+QtBS8BfwbeCSd3hRa2HKV4/8pBZF+2H6R5AuTX5Q4TrUiYlVE/JXky6djShwn42bgkoj4sNRBahIR8yNickRURsSSiPgFsJikO7BZo3CBVSTpt8jvA5+N5pWeoNyF5NsUy4OkMcCfgAMj4sVS58lDG6ATSUtHqX2D5CTuqZIW8fl5Q1PUNEfrq0rvm8rgB0TEUmAWELmzqplWSscDkyPi1VIHybEhybfI10bEsohYHRE3k/zv2bm00RIR8WFEjIyIvhGxGfAe8CkwvsTRqjOZrP8pqWE0wa7TTVk6KMhLwN8i4uSIaEq/y9VpQzIIS1PwbeDXaXfpRcCuwC8kvVTiXHWpogn9b7GWzwVWcd0InCVpM0ldgCuApyNiVmljJZQMI78B0C59vkF6axJ/hCSdSjJy23ci4p+lzpNLydDnJ6fdTFAy/Pl1JB/I365t3UZyP7AFSVeJocB+6fS9aQLn6aTD7HZLHw8C/h/waER8WtJgX3Y9MEbSNulAEmNJWjyaxLC/ktqRdF9sUq1XAOl5Vu8AJ0nqJKmNpKNIuro1iS+aJG0tacP093lH4Brg8lJ1tazj7/IdwAhJoyS1lTQKGA7c3kTyffac5MNs2/R5ow6oVVtGSV8BXgbujYgzGzNXnvkOk7Rd+ruygaRjgT2Ap5tCPqAfyTl/Q9PbBJL/e//bWPnqyihpD0lbpr/TnSVdQDKCaaMdQzMiwrci3UjOO7iKpKtJOcnwuj1LnSsr32g+/yY++zaw1NnSfAGsITlv47NbqXNl5WtF0jd+IbAC+BC4G9ii1NlqyDswPaabljpLmmccSbeNFSStBlcDXUqdq5qcAi4C5pOc7/IiydD8Jc+W5juCpItY51JnqSHfV4HH07+DS0kGaTi41Lmy8h0LzCO5jMG7wGklzlPr32VgH+BNYGV6v3cTy1fdvAuaSkbg1vTx8pzbkU0k38npz+Hy9O/jv4DDm8rxq2bZccB5jZkvj2N4OjA7/d+yEHgK2LGxM/q2ft8U0dRbxs3MzMzMzJoHdxE0MzMzMzMrEBdYZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIC6wzMzWY5IukPTcOqx/jqTH1jHDDEmj12UbZmZmTYULLDOzRiJpc0l/kTRf0nJJH0h6WFK7UmdrqIj4dUQcWOocZmZmTYULLDOzxvMkMA/YGigDdgaeBlTKUGZmZlY4LrDMzBqBpB4khdUNEbE0EnMi4oaIWJUuM0TS3yUtkvSJpL9J2iJrG7dJulPSLZKWSPpQ0ihJQyX9R1K5pBclbZy1zixJv5L0ctpqNkHSjrXk7CjpKknvSVos6SlJW9ay/Be6GKb7O0fS8+n+pkraJWt+W0lXS1qYtuSdVc02d0vzLpY0U9LPJCmdd6ekZyS1Sp/vLmmZpO3yfS/MzMyKyQWWmVkjiIiPgTeBmyX9SNI2maIhezHgAmATYCCwHLgrZ5n/BR4ENgQuBm4CLgIOBTZKt3FhzjonAKel6zwAPCmpSw1RbwK+Anwd6AO8CjwuqW09Xu5RwKlAV+BZ4PaseWcDBwC7AJulr3NAZqakbUha+q4EegH7AycDP8x6LZsC50naCLgXOC0i3qhHPjMzs6JxgWVm1nh2B8YBPwVeBxZI+mWm0IqIKRHxYkSsioilJIXS1yV1zNrGCxHxRERUAXcAnYA709awCpICakTOfv8cERMjYjVwBbCSpMj5Akk9ge8DJ0XEgnT5C4G+wNfq8Tr/FBFvRsRa4GZgS0ld03k/Aq6IiBkRsRI4k6QozDgJ+EtEPBIRayPibeAP6XpExArg8HS9Z4GnIuLWemQzMzMrqjalDmBmtr6IiEXAOcA5adH0PZIWow+BW9LugFeSFDNlfF549AJmp4/nZW2vIq3NPpsGVKTrZpuVtU5Iep+kFSjXZun9lJzGtbZAv7xeZE5GYEV6XwYsTfebnWeFpIU5GfaQ9N2saa2AD7LWeVPSi8CBwCH1yGVmZlZ0bsEyMyuBiKiIiNuAKcDQdPINQDmwfUR0AXZNp6/rIBgDMw/S1rL+wJxqlssUcYMiolvWrWNE3LuOGTI+zMnTiaSAzM5wS87+u0TEtlnr/ICkC+MDJF0u/b/MzMyaDP9TMjNrBJK6S7pM0uB0oIc2kg4DBgMvpYt1IWnxWZJ217uoQLs/StIO6XlUY4GOwBO5C0XEQuAe4HpJm6S5u0k6VFLnAmW5ExgraQtJHYDf8MX/RdcDR0g6MOs4bSPpm2merwLXAUcCPwZ6kpy3ZmZm1iS4wDIzaxyrgd7AQ8Bi4CPgPODUiPhLuszpwG7AMpKi6/EC7ftG4PfAJ8BIYP/0HK/qHAtMB8ZJKgfeIDnnKWpYvr4uIxmafjzwHvA+n7ecERFTSc4P+ylJV8OFwG1Ar7Rb5V+A30bEc+k5XN8DTpP07QLlMzMzWyeKKNT/TDMza2okzQLOi4jc0QjNzMysCNyCZWZmZmZmViAusMzMzMzMzArEXQTNzMzMzMwKxC1YZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIP8f/zK+xPjueGcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 2,\n", + " 'train_size': 2,\n", + " 'n_splits': 2\n", + "}\n", + "\n", + "test_cv(X, y, groups, **cv_args)\n", + "plot_cv(X, y, groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Groups are not sorted**" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['2021-06',\n", + " '2021-06',\n", + " '2021-06',\n", + " '2021-06',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-04',\n", + " '2021-04',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-05',\n", + " '2021-05',\n", + " '2021-01']" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not_sorted_months = ['2021-06', '2021-06', '2021-06', '2021-06', '2021-02', '2021-02', \n", + " '2021-02', '2021-02', '2021-04', '2021-04', '2021-03', '2021-03', \n", + " '2021-03', '2021-05', '2021-05', '2021-01']\n", + "not_sorted_months" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([5, 5, 5, 5, 1, 1, 1, 1, 3, 3, 2, 2, 2, 4, 4, 0])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not_sorted_groups = np.fromiter(map(months_map.get, not_sorted_months), dtype='int')\n", + "not_sorted_groups" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
num_feature
2021-060
2021-067
2021-066
2021-064
2021-024
2021-028
2021-020
2021-026
2021-042
2021-040
2021-035
2021-039
2021-037
2021-057
2021-057
2021-017
\n", + "
" + ], + "text/plain": [ + " num_feature\n", + "2021-06 0\n", + "2021-06 7\n", + "2021-06 6\n", + "2021-06 4\n", + "2021-02 4\n", + "2021-02 8\n", + "2021-02 0\n", + "2021-02 6\n", + "2021-04 2\n", + "2021-04 0\n", + "2021-03 5\n", + "2021-03 9\n", + "2021-03 7\n", + "2021-05 7\n", + "2021-05 7\n", + "2021-01 7" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_not_sorted = X.copy()\n", + "X_not_sorted.index = not_sorted_months\n", + "X_not_sorted" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4 5 6 7 8 9]\n", + "TEST INDICES: [10 11 12]\n", + "TRAIN LENGTH: 10\n", + "TEST LENGTH: 3\n", + "TRAIN GROUPS: [5 5 5 5 1 1 1 1 3 3]\n", + "TEST GROUPS: [2 2 2]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06' '2021-02' '2021-02' '2021-02'\n", + " '2021-02' '2021-04' '2021-04']\n", + "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03']\n", + "\n", + "TRAIN INDICES: [ 4 5 6 7 8 9 10 11 12]\n", + "TEST INDICES: [13 14]\n", + "TRAIN LENGTH: 9\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: [1 1 1 1 3 3 2 2 2]\n", + "TEST GROUPS: [4 4]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-04' '2021-04' '2021-03'\n", + " '2021-03' '2021-03']\n", + "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [ 8 9 10 11 12 13 14]\n", + "TEST INDICES: [15]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 1\n", + "TRAIN GROUPS: [3 3 2 2 2 4 4]\n", + "TEST GROUPS: [0]\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-04' '2021-04' '2021-03' '2021-03' '2021-03' '2021-05' '2021-05']\n", + "TEST GROUP MONTHS: ['2021-01']\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'train_size': 3\n", + "}\n", + "\n", + "test_cv(X_not_sorted, y, not_sorted_groups, **cv_args)\n", + "plot_cv(X_not_sorted, y, not_sorted_groups, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Group names**" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", + "TEST INDICES: [8 9]\n", + "TRAIN LENGTH: 8\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03']\n", + "TEST GROUPS: ['2021-04' '2021-04']\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03']\n", + "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", + "\n", + "TRAIN INDICES: [1 2 3 4 5 6 7 8 9]\n", + "TEST INDICES: [10 11]\n", + "TRAIN LENGTH: 9\n", + "TEST LENGTH: 2\n", + "TRAIN GROUPS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", + " '2021-04' '2021-04']\n", + "TEST GROUPS: ['2021-05' '2021-05']\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", + " '2021-04' '2021-04']\n", + "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", + "\n", + "TRAIN INDICES: [ 5 6 7 8 9 10 11]\n", + "TEST INDICES: [12 13 14 15]\n", + "TRAIN LENGTH: 7\n", + "TEST LENGTH: 4\n", + "TRAIN GROUPS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "TEST GROUPS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "TRAIN GROUP SIZE: 3\n", + "TEST GROUP SIZE: 1\n", + "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'train_size': 3\n", + "}\n", + "\n", + "test_cv(X, y, months, **cv_args)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Usage in CV" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.5 , 0.25])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'train_size': 3\n", + "}\n", + "cv = GroupTimeSeriesSplit(**cv_args)\n", + "clf = DummyClassifier(strategy='most_frequent')\n", + "\n", + "scores = cross_val_score(clf, X, y, groups=groups, scoring='accuracy', cv=cv)\n", + "scores" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 0 1 0 1 0 0 1] [0 0 0 0 0 0 0 0] [1 1] [0 0]\n", + "[0 1 0 1 0 0 1 1 1] [1 1 1 1 1 1 1 1 1] [0 1] [1 1]\n", + "[0 0 1 1 1 0 1] [1 1 1 1 1 1 1] [1 0 0 0] [1 1 1 1]\n" + ] + } + ], + "source": [ + "clf = DummyClassifier(strategy='most_frequent')\n", + "\n", + "for train_idx, test_idx in cv.split(X, y, groups):\n", + " clf.fit(X.iloc[train_idx], y.iloc[train_idx])\n", + " y_train_pred = clf.predict(X.iloc[train_idx])\n", + " y_test_pred = clf.predict(X.iloc[test_idx])\n", + " print(y.iloc[train_idx].values, y_train_pred,\n", + " y.iloc[test_idx].values, y_test_pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Failed cases" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Groups are not consecutive\n", + "- Both train_size and n_splits are specified\n", + "- Incorrect window name\n", + "- Specify train_size with expanding window\n", + "- Not enough data (too many number of splits)\n", + "- Not enough data (too large value of shift size)\n", + "- Not enough data (too large value of gap size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Groups are not consecutive**" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['2021-01',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-02',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-04',\n", + " '2021-04',\n", + " '2021-05',\n", + " '2021-05',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-03',\n", + " '2021-03']" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not_consecutive_months = ['2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03',\n", + " '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05',\n", + " '2021-03', '2021-03', '2021-03', '2021-03']\n", + "not_consecutive_months" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 2, 2, 2, 2])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not_consecutive_groups = np.fromiter(map(months_map.get, not_consecutive_months), dtype='int')\n", + "not_consecutive_groups" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The groups should be consecutive\n" + ] + } + ], + "source": [ + "try:\n", + " test_cv(X, y, not_consecutive_groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Both train_size and n_splits are not specified**" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Either train_size or n_splits should be defined\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 3\n", + "}\n", + "\n", + "try:\n", + " test_cv(X, y, groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Incorrect window name**" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Window type can be either \"rolling\" or \"expanding\"\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 3,\n", + " 'n_splits': 3,\n", + " 'window_type': 'bad_name'\n", + "}\n", + "\n", + "try:\n", + " test_cv(X, y, groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Specify train_size with expanding window**" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train size can be specified only with rolling window\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 3,\n", + " 'train_size': 3,\n", + " 'window_type': 'expanding'\n", + "}\n", + "\n", + "try:\n", + " test_cv(X, y, groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Not enough data (too large train_size and/or n_splits)**" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not enough data to split number of groups (6) for number splits (10) with train size (10), test size (1), gap size (0), shift size (1)\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'train_size': 10, \n", + " 'n_splits': 10\n", + "}\n", + "\n", + "try:\n", + " test_cv(X, y, groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Not enough data (too many number of splits)**" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not enough data to split number of groups (6) for number splits (10) with train size (-4), test size (1), gap size (0), shift size (1)\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'n_splits': 10\n", + "}\n", + "\n", + "try:\n", + " test_cv(X, y, groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Not enough data (too large values of shift size)**" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not enough data to split number of groups (6) for number splits (3) with train size (-15), test size (1), gap size (0), shift size (10)\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'n_splits': 3,\n", + " 'shift_size': 10\n", + "}\n", + "\n", + "try:\n", + " test_cv(X, y, groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Not enough data (too large values of gap size)**" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not enough data to split number of groups (6) for number splits (3) with train size (-7), test size (1), gap size (10), shift size (1)\n" + ] + } + ], + "source": [ + "cv_args = {\n", + " 'test_size': 1,\n", + " 'n_splits': 3,\n", + " 'gap_size': 10\n", + "}\n", + "\n", + "try:\n", + " test_cv(X, y, groups, **cv_args)\n", + "except ValueError as e:\n", + " print(e)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mlxtend", + "language": "python", + "name": "mlxtend" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 2bd1ee150d26cd0b2df35841ad2ecd98c6aac2fd Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Tue, 3 May 2022 14:17:30 +0300 Subject: [PATCH 20/30] Reformat notebook using black --- .../evaluate/GroupTimeSeriesSplit.ipynb | 270 +++++++++--------- 1 file changed, 130 insertions(+), 140 deletions(-) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index f66b430cc..c5fc5fde1 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -36,6 +36,7 @@ "from matplotlib.patches import Patch\n", "import matplotlib.pyplot as plt\n", "from matplotlib.ticker import MaxNLocator\n", + "\n", "%matplotlib inline\n", "\n", "from mlxtend.evaluate.time_series import GroupTimeSeriesSplit" @@ -72,7 +73,7 @@ } ], "source": [ - "months_map = {f'2021-0{i+1}': i for i in range(6)}\n", + "months_map = {f\"2021-0{i+1}\": i for i in range(6)}\n", "months_map" ] }, @@ -108,9 +109,24 @@ } ], "source": [ - "months = ['2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03',\n", - " '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05',\n", - " '2021-06', '2021-06', '2021-06', '2021-06']\n", + "months = [\n", + " \"2021-01\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-04\",\n", + " \"2021-04\",\n", + " \"2021-05\",\n", + " \"2021-05\",\n", + " \"2021-06\",\n", + " \"2021-06\",\n", + " \"2021-06\",\n", + " \"2021-06\",\n", + "]\n", "months" ] }, @@ -131,7 +147,7 @@ } ], "source": [ - "groups = np.fromiter(map(months_map.get, months), dtype='int')\n", + "groups = np.fromiter(map(months_map.get, months), dtype=\"int\")\n", "groups" ] }, @@ -293,8 +309,8 @@ "data = [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]]\n", "target = [1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0]\n", "\n", - "X = pd.DataFrame(data, index=months, columns=['num_feature'])\n", - "y = pd.Series(target, name='target')\n", + "X = pd.DataFrame(data, index=months, columns=[\"num_feature\"])\n", + "y = pd.Series(target, name=\"target\")\n", "\n", "display(X, y)" ] @@ -315,35 +331,37 @@ "def test_cv(X, y, groups, **cv_args):\n", " cv = GroupTimeSeriesSplit(**cv_args)\n", " groups = np.array(groups)\n", - " \n", + "\n", " for train_idx, test_idx in cv.split(X, groups=groups):\n", - " print('TRAIN INDICES:', train_idx)\n", - " print('TEST INDICES:', test_idx)\n", - " print('TRAIN LENGTH:', len(train_idx))\n", - " print('TEST LENGTH:', len(test_idx))\n", - " print('TRAIN GROUPS:', groups[train_idx]) \n", - " print('TEST GROUPS:', groups[test_idx])\n", - " print('TRAIN GROUP SIZE:', len(set(groups[train_idx]))) \n", - " print('TEST GROUP SIZE:', len(set(groups[test_idx])))\n", - " print('TRAIN GROUP MONTHS:', X.index[train_idx].values) \n", - " print('TEST GROUP MONTHS:', X.index[test_idx].values)\n", + " print(\"TRAIN INDICES:\", train_idx)\n", + " print(\"TEST INDICES:\", test_idx)\n", + " print(\"TRAIN LENGTH:\", len(train_idx))\n", + " print(\"TEST LENGTH:\", len(test_idx))\n", + " print(\"TRAIN GROUPS:\", groups[train_idx])\n", + " print(\"TEST GROUPS:\", groups[test_idx])\n", + " print(\"TRAIN GROUP SIZE:\", len(set(groups[train_idx])))\n", + " print(\"TEST GROUP SIZE:\", len(set(groups[test_idx])))\n", + " print(\"TRAIN GROUP MONTHS:\", X.index[train_idx].values)\n", + " print(\"TEST GROUP MONTHS:\", X.index[test_idx].values)\n", " print()\n", "\n", - "def plot_cv_indices(cv, X, y, groups, n_splits,\n", - " image_file_path=None):\n", + "\n", + "def plot_cv_indices(cv, X, y, groups, n_splits, image_file_path=None):\n", " \"\"\"Create a sample plot for indices of a cross-validation object.\"\"\"\n", - " \n", + "\n", " fig, ax = plt.subplots(figsize=(12, 4))\n", " cmap_data = plt.cm.tab20\n", " cmap_cv = plt.cm.coolwarm\n", " lw = 10\n", " marker_size = 200\n", - " \n", - " for split_idx, (train_idx, test_idx) in enumerate(cv.split(X=X, y=y, groups=groups)):\n", + "\n", + " for split_idx, (train_idx, test_idx) in enumerate(\n", + " cv.split(X=X, y=y, groups=groups)\n", + " ):\n", " indices = np.array([np.nan] * len(X))\n", " indices[test_idx] = 1\n", " indices[train_idx] = 0\n", - " \n", + "\n", " ax.scatter(\n", " range(len(X)),\n", " [split_idx + 0.5] * len(X),\n", @@ -353,51 +371,55 @@ " cmap=cmap_cv,\n", " vmin=-0.4,\n", " vmax=1.4,\n", - " s=marker_size\n", + " s=marker_size,\n", " )\n", " ax.scatter(\n", - " range(len(X)), [split_idx + 1.5] * len(X), \n", - " c=groups, marker=\"_\", lw=lw, \n", - " cmap=cmap_data, s=marker_size\n", + " range(len(X)),\n", + " [split_idx + 1.5] * len(X),\n", + " c=groups,\n", + " marker=\"_\",\n", + " lw=lw,\n", + " cmap=cmap_data,\n", + " s=marker_size,\n", " )\n", "\n", - " yticklabels = list(range(n_splits)) + ['group']\n", + " yticklabels = list(range(n_splits)) + [\"group\"]\n", " ax.set(\n", " yticks=np.arange(n_splits + 1) + 0.5,\n", " yticklabels=yticklabels,\n", - " ylabel='CV iteration',\n", + " ylabel=\"CV iteration\",\n", " ylim=[n_splits + 1.2, -0.2],\n", - " xlim=[-0.5, len(indices) - 0.5]\n", + " xlim=[-0.5, len(indices) - 0.5],\n", " )\n", " ax.legend(\n", " [Patch(color=cmap_cv(0.2)), Patch(color=cmap_cv(0.8))],\n", " [\"Training set\", \"Testing set\"],\n", " loc=(1.02, 0.8),\n", - " fontsize=13\n", + " fontsize=13,\n", " )\n", - " \n", - " ax.set_title('{}\\n{}'.format(type(cv).__name__, cv_args), fontsize=15)\n", + "\n", + " ax.set_title(\"{}\\n{}\".format(type(cv).__name__, cv_args), fontsize=15)\n", " ax.xaxis.set_major_locator(MaxNLocator(min_n_ticks=len(X), integer=True))\n", - " ax.set_xlabel(xlabel='Sample index', fontsize=13)\n", - " ax.set_ylabel(ylabel='CV iteration', fontsize=13)\n", - " ax.tick_params(axis='both', which='major', labelsize=13)\n", - " ax.tick_params(axis='both', which='minor', labelsize=13)\n", - " \n", + " ax.set_xlabel(xlabel=\"Sample index\", fontsize=13)\n", + " ax.set_ylabel(ylabel=\"CV iteration\", fontsize=13)\n", + " ax.tick_params(axis=\"both\", which=\"major\", labelsize=13)\n", + " ax.tick_params(axis=\"both\", which=\"minor\", labelsize=13)\n", + "\n", " plt.tight_layout()\n", - " \n", + "\n", " if image_file_path:\n", - " plt.savefig(image_file_path, bbox_inches='tight')\n", - " \n", + " plt.savefig(image_file_path, bbox_inches=\"tight\")\n", + "\n", " plt.show()\n", - " \n", + "\n", + "\n", "def plot_cv(X, y, groups, image_file_path=None, **cv_args):\n", " cv = GroupTimeSeriesSplit(**cv_args)\n", " cv._n_groups = len(np.unique(groups))\n", " cv._calculate_split_params()\n", " n_splits = cv.n_splits\n", - " \n", - " plot_cv_indices(cv, X, y, groups, n_splits,\n", - " image_file_path=image_file_path)" + "\n", + " plot_cv_indices(cv, X, y, groups, n_splits, image_file_path=image_file_path)" ] }, { @@ -415,10 +437,7 @@ "metadata": {}, "outputs": [], "source": [ - "cv_args = {\n", - " 'test_size': 3, \n", - " 'n_splits': 1\n", - "}" + "cv_args = {\"test_size\": 3, \"n_splits\": 1}" ] }, { @@ -562,10 +581,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'train_size': 3\n", - "}\n", + "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", "\n", "test_cv(X, y, groups, **cv_args)\n", "plot_cv(X, y, groups, **cv_args)" @@ -636,10 +652,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 2,\n", - " 'n_splits': 3\n", - "}\n", + "cv_args = {\"test_size\": 2, \"n_splits\": 3}\n", "\n", "test_cv(X, y, groups, **cv_args)\n", "plot_cv(X, y, groups, **cv_args)" @@ -710,11 +723,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'n_splits': 3,\n", - " 'gap_size': 1\n", - "}\n", + "cv_args = {\"test_size\": 1, \"n_splits\": 3, \"gap_size\": 1}\n", "\n", "test_cv(X, y, groups, **cv_args)\n", "plot_cv(X, y, groups, **cv_args)" @@ -775,11 +784,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'n_splits': 2,\n", - " 'shift_size': 2\n", - "}\n", + "cv_args = {\"test_size\": 1, \"n_splits\": 2, \"shift_size\": 2}\n", "\n", "test_cv(X, y, groups, **cv_args)\n", "plot_cv(X, y, groups, **cv_args)" @@ -853,11 +858,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 3,\n", - " 'n_splits': 3,\n", - " 'window_type': 'expanding'\n", - "}\n", + "cv_args = {\"test_size\": 3, \"n_splits\": 3, \"window_type\": \"expanding\"}\n", "\n", "test_cv(X, y, groups, **cv_args)\n", "plot_cv(X, y, groups, **cv_args)" @@ -918,11 +919,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 3,\n", - " 'train_size': 2,\n", - " 'n_splits': 2\n", - "}\n", + "cv_args = {\"test_size\": 3, \"train_size\": 2, \"n_splits\": 2}\n", "\n", "test_cv(X, y, groups, **cv_args)\n", "plot_cv(X, y, groups, **cv_args)" @@ -982,11 +979,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 2,\n", - " 'train_size': 2,\n", - " 'n_splits': 2\n", - "}\n", + "cv_args = {\"test_size\": 2, \"train_size\": 2, \"n_splits\": 2}\n", "\n", "test_cv(X, y, groups, **cv_args)\n", "plot_cv(X, y, groups, **cv_args)" @@ -1031,9 +1024,24 @@ } ], "source": [ - "not_sorted_months = ['2021-06', '2021-06', '2021-06', '2021-06', '2021-02', '2021-02', \n", - " '2021-02', '2021-02', '2021-04', '2021-04', '2021-03', '2021-03', \n", - " '2021-03', '2021-05', '2021-05', '2021-01']\n", + "not_sorted_months = [\n", + " \"2021-06\",\n", + " \"2021-06\",\n", + " \"2021-06\",\n", + " \"2021-06\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-04\",\n", + " \"2021-04\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-05\",\n", + " \"2021-05\",\n", + " \"2021-01\",\n", + "]\n", "not_sorted_months" ] }, @@ -1054,7 +1062,7 @@ } ], "source": [ - "not_sorted_groups = np.fromiter(map(months_map.get, not_sorted_months), dtype='int')\n", + "not_sorted_groups = np.fromiter(map(months_map.get, not_sorted_months), dtype=\"int\")\n", "not_sorted_groups" ] }, @@ -1247,10 +1255,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'train_size': 3\n", - "}\n", + "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", "\n", "test_cv(X_not_sorted, y, not_sorted_groups, **cv_args)\n", "plot_cv(X_not_sorted, y, not_sorted_groups, **cv_args)" @@ -1313,10 +1318,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'train_size': 3\n", - "}\n", + "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", "\n", "test_cv(X, y, months, **cv_args)" ] @@ -1345,14 +1347,11 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'train_size': 3\n", - "}\n", + "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", "cv = GroupTimeSeriesSplit(**cv_args)\n", - "clf = DummyClassifier(strategy='most_frequent')\n", + "clf = DummyClassifier(strategy=\"most_frequent\")\n", "\n", - "scores = cross_val_score(clf, X, y, groups=groups, scoring='accuracy', cv=cv)\n", + "scores = cross_val_score(clf, X, y, groups=groups, scoring=\"accuracy\", cv=cv)\n", "scores" ] }, @@ -1372,14 +1371,13 @@ } ], "source": [ - "clf = DummyClassifier(strategy='most_frequent')\n", + "clf = DummyClassifier(strategy=\"most_frequent\")\n", "\n", "for train_idx, test_idx in cv.split(X, y, groups):\n", " clf.fit(X.iloc[train_idx], y.iloc[train_idx])\n", " y_train_pred = clf.predict(X.iloc[train_idx])\n", " y_test_pred = clf.predict(X.iloc[test_idx])\n", - " print(y.iloc[train_idx].values, y_train_pred,\n", - " y.iloc[test_idx].values, y_test_pred)" + " print(y.iloc[train_idx].values, y_train_pred, y.iloc[test_idx].values, y_test_pred)" ] }, { @@ -1441,9 +1439,24 @@ } ], "source": [ - "not_consecutive_months = ['2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03',\n", - " '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05',\n", - " '2021-03', '2021-03', '2021-03', '2021-03']\n", + "not_consecutive_months = [\n", + " \"2021-01\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-02\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-04\",\n", + " \"2021-04\",\n", + " \"2021-05\",\n", + " \"2021-05\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + " \"2021-03\",\n", + "]\n", "not_consecutive_months" ] }, @@ -1464,7 +1477,9 @@ } ], "source": [ - "not_consecutive_groups = np.fromiter(map(months_map.get, not_consecutive_months), dtype='int')\n", + "not_consecutive_groups = np.fromiter(\n", + " map(months_map.get, not_consecutive_months), dtype=\"int\"\n", + ")\n", "not_consecutive_groups" ] }, @@ -1509,9 +1524,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 3\n", - "}\n", + "cv_args = {\"test_size\": 3}\n", "\n", "try:\n", " test_cv(X, y, groups, **cv_args)\n", @@ -1540,11 +1553,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 3,\n", - " 'n_splits': 3,\n", - " 'window_type': 'bad_name'\n", - "}\n", + "cv_args = {\"test_size\": 3, \"n_splits\": 3, \"window_type\": \"bad_name\"}\n", "\n", "try:\n", " test_cv(X, y, groups, **cv_args)\n", @@ -1573,11 +1582,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 3,\n", - " 'train_size': 3,\n", - " 'window_type': 'expanding'\n", - "}\n", + "cv_args = {\"test_size\": 3, \"train_size\": 3, \"window_type\": \"expanding\"}\n", "\n", "try:\n", " test_cv(X, y, groups, **cv_args)\n", @@ -1606,11 +1611,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'train_size': 10, \n", - " 'n_splits': 10\n", - "}\n", + "cv_args = {\"test_size\": 1, \"train_size\": 10, \"n_splits\": 10}\n", "\n", "try:\n", " test_cv(X, y, groups, **cv_args)\n", @@ -1639,10 +1640,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'n_splits': 10\n", - "}\n", + "cv_args = {\"test_size\": 1, \"n_splits\": 10}\n", "\n", "try:\n", " test_cv(X, y, groups, **cv_args)\n", @@ -1671,11 +1669,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'n_splits': 3,\n", - " 'shift_size': 10\n", - "}\n", + "cv_args = {\"test_size\": 1, \"n_splits\": 3, \"shift_size\": 10}\n", "\n", "try:\n", " test_cv(X, y, groups, **cv_args)\n", @@ -1704,11 +1698,7 @@ } ], "source": [ - "cv_args = {\n", - " 'test_size': 1,\n", - " 'n_splits': 3,\n", - " 'gap_size': 10\n", - "}\n", + "cv_args = {\"test_size\": 1, \"n_splits\": 3, \"gap_size\": 10}\n", "\n", "try:\n", " test_cv(X, y, groups, **cv_args)\n", From 7cadc4cfeba3c7a8debefae5bd07f555ffe25d2d Mon Sep 17 00:00:00 2001 From: rasbt Date: Wed, 11 May 2022 16:59:13 -0500 Subject: [PATCH 21/30] isort --- mlxtend/evaluate/__init__.py | 7 ++----- mlxtend/evaluate/tests/test_time_series.py | 3 ++- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index 014e27c22..01e0eb2ea 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -20,13 +20,10 @@ from .mcnemar import mcnemar, mcnemar_table, mcnemar_tables from .permutation import permutation_test from .proportion_difference import proportion_difference -from .bias_variance_decomp import bias_variance_decomp -from .accuracy import accuracy_score -from .counterfactual import create_counterfactual from .scoring import scoring from .time_series import GroupTimeSeriesSplit -from .ttest import paired_ttest_5x2cv, paired_ttest_kfold_cv, paired_ttest_resampled - +from .ttest import (paired_ttest_5x2cv, paired_ttest_kfold_cv, + paired_ttest_resampled) __all__ = [ "scoring", diff --git a/mlxtend/evaluate/tests/test_time_series.py b/mlxtend/evaluate/tests/test_time_series.py index 1ec260b71..8233e0ba8 100644 --- a/mlxtend/evaluate/tests/test_time_series.py +++ b/mlxtend/evaluate/tests/test_time_series.py @@ -7,10 +7,11 @@ import numpy as np import pytest -from mlxtend.evaluate import GroupTimeSeriesSplit from sklearn.dummy import DummyClassifier from sklearn.model_selection import cross_val_score +from mlxtend.evaluate import GroupTimeSeriesSplit + @pytest.fixture def X(): From 96919e59248754ed27fe14f1f8bb06b2bdf5779d Mon Sep 17 00:00:00 2001 From: rasbt Date: Wed, 11 May 2022 17:47:02 -0500 Subject: [PATCH 22/30] isort with black profile --- mlxtend/evaluate/__init__.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mlxtend/evaluate/__init__.py b/mlxtend/evaluate/__init__.py index 01e0eb2ea..7c76fec88 100644 --- a/mlxtend/evaluate/__init__.py +++ b/mlxtend/evaluate/__init__.py @@ -22,8 +22,7 @@ from .proportion_difference import proportion_difference from .scoring import scoring from .time_series import GroupTimeSeriesSplit -from .ttest import (paired_ttest_5x2cv, paired_ttest_kfold_cv, - paired_ttest_resampled) +from .ttest import paired_ttest_5x2cv, paired_ttest_kfold_cv, paired_ttest_resampled __all__ = [ "scoring", From 0010304baaddf1fc826ba4822aed3d168d548908 Mon Sep 17 00:00:00 2001 From: rasbt Date: Sat, 14 May 2022 09:58:23 -0500 Subject: [PATCH 23/30] add description at the top --- .../evaluate/GroupTimeSeriesSplit.ipynb | 20 ++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index c5fc5fde1..ff971b8e4 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -7,6 +7,20 @@ "# GroupTimeSeriesSplit: A scikit-learn compatible version of the time series validation with groups" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A scikit-learn-compatible time series cross-validator that supports non-overlapping groups." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> `from mlxtend.evaluate import GroupTimeSeriesSplit` " + ] + }, { "cell_type": "code", "execution_count": 1, @@ -1709,9 +1723,9 @@ ], "metadata": { "kernelspec": { - "display_name": "mlxtend", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "mlxtend" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1723,7 +1737,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.7" } }, "nbformat": 4, From 82eb1246fca5a2483997b8b056de2b37044ffe63 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sun, 15 May 2022 13:45:51 +0300 Subject: [PATCH 24/30] Prepare description and code for documentation --- .../evaluate/GroupTimeSeriesSplit.ipynb | 1873 ++++------------- mlxtend/evaluate/time_series.py | 117 + 2 files changed, 566 insertions(+), 1424 deletions(-) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index ff971b8e4..1761a1b07 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -22,15 +22,37 @@ ] }, { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "tags": [] - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, "source": [ - "%load_ext autoreload\n", - "%autoreload 2" + "Time series tasks in machine learning require special type of validation, because the time order of the objects is important if we want to get more fair evaluation of the ML model’s quality. \n", + "Also there can be different units for splitting the data for different tasks - hours, days, months etc. \n", + "\n", + "Here, we use time series validation with support of the groups which can be flexibly configured along with other parameters:\n", + "\n", + "- Test size\n", + "- Train size\n", + "- Number of splits\n", + "- Gap size\n", + "- Shift size \n", + "- Window type \n", + "\n", + "There are several features that need to be taken into account:\n", + "\n", + "- Implementation is compatible with sklearn-learn API\n", + "- It can be used both for holdout split and cross-validation\n", + "- Numbers or custom non-numeric values can be used as groups\n", + "- Groups should be consecutive\n", + "- Test size with either train size or number of splits are required parameters for splitting\n", + "- If full data can’t be used with specific parameters, the most recent data is considered to split\n", + "- If split is impossible (e.g., the data is not enough to split) using specified parameters, an exception will be raised " ] }, { @@ -39,21 +61,17 @@ "metadata": {}, "outputs": [], "source": [ - "from pathlib import Path\n", - "\n", - "from IPython.display import display\n", "import numpy as np\n", "import pandas as pd\n", "from sklearn.dummy import DummyClassifier\n", "from sklearn.model_selection import cross_val_score\n", "\n", - "from matplotlib.patches import Patch\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.ticker import MaxNLocator\n", - "\n", - "%matplotlib inline\n", - "\n", - "from mlxtend.evaluate.time_series import GroupTimeSeriesSplit" + "from mlxtend.evaluate.time_series import (\n", + " GroupTimeSeriesSplit,\n", + " plot_splits,\n", + " print_cv_info,\n", + " print_split_info,\n", + ")" ] }, { @@ -65,6 +83,13 @@ "## Prepare sample data" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Group numbers" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -73,12 +98,7 @@ { "data": { "text/plain": [ - "{'2021-01': 0,\n", - " '2021-02': 1,\n", - " '2021-03': 2,\n", - " '2021-04': 3,\n", - " '2021-05': 4,\n", - " '2021-06': 5}" + "array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5])" ] }, "execution_count": 3, @@ -87,8 +107,15 @@ } ], "source": [ - "months_map = {f\"2021-0{i+1}\": i for i in range(6)}\n", - "months_map" + "groups = np.array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5])\n", + "groups" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Group names (months)" ] }, { @@ -99,22 +126,9 @@ { "data": { "text/plain": [ - "['2021-01',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-04',\n", - " '2021-04',\n", - " '2021-05',\n", - " '2021-05',\n", - " '2021-06',\n", - " '2021-06',\n", - " '2021-06',\n", - " '2021-06']" + "array(['2021-01', '2021-02', '2021-02', '2021-02', '2021-02', '2021-03',\n", + " '2021-03', '2021-03', '2021-04', '2021-04', '2021-05', '2021-05',\n", + " '2021-06', '2021-06', '2021-06', '2021-06'], dtype='\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
num_feature
2021-010
2021-027
2021-026
2021-024
2021-024
2021-038
2021-030
2021-036
2021-042
2021-040
2021-055
2021-059
2021-067
2021-067
2021-067
2021-067
\n", - "" - ], + "image/png": "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\n", "text/plain": [ - " num_feature\n", - "2021-01 0\n", - "2021-02 7\n", - "2021-02 6\n", - "2021-02 4\n", - "2021-02 4\n", - "2021-03 8\n", - "2021-03 0\n", - "2021-03 6\n", - "2021-04 2\n", - "2021-04 0\n", - "2021-05 5\n", - "2021-05 9\n", - "2021-06 7\n", - "2021-06 7\n", - "2021-06 7\n", - "2021-06 7" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" }, { - "data": { - "text/plain": [ - "0 1\n", - "1 0\n", - "2 1\n", - "3 0\n", - "4 1\n", - "5 0\n", - "6 0\n", - "7 1\n", - "8 1\n", - "9 1\n", - "10 0\n", - "11 1\n", - "12 1\n", - "13 0\n", - "14 0\n", - "15 0\n", - "Name: target, dtype: int64" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Train indices: [0 1 2 3 4 5 6 7]\n", + "Test indices: [8 9]\n", + "Train length: 8\n", + "Test length: 2\n", + "Train groups: [0 1 1 1 1 2 2 2]\n", + "Test groups: [3 3]\n", + "Train group size: 3\n", + "Test group size: 1\n", + "Train group months: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03']\n", + "Test group months: ['2021-04' '2021-04']\n", + "\n", + "Train indices: [1 2 3 4 5 6 7 8 9]\n", + "Test indices: [10 11]\n", + "Train length: 9\n", + "Test length: 2\n", + "Train groups: [1 1 1 1 2 2 2 3 3]\n", + "Test groups: [4 4]\n", + "Train group size: 3\n", + "Test group size: 1\n", + "Train group months: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", + " '2021-04' '2021-04']\n", + "Test group months: ['2021-05' '2021-05']\n", + "\n", + "Train indices: [ 5 6 7 8 9 10 11]\n", + "Test indices: [12 13 14 15]\n", + "Train length: 7\n", + "Test length: 4\n", + "Train groups: [2 2 2 3 3 4 4]\n", + "Test groups: [5 5 5 5]\n", + "Train group size: 3\n", + "Test group size: 1\n", + "Train group months: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "Test group months: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] } ], "source": [ - "data = [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]]\n", - "target = [1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0]\n", - "\n", - "X = pd.DataFrame(data, index=months, columns=[\"num_feature\"])\n", - "y = pd.Series(target, name=\"target\")\n", + "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", "\n", - "display(X, y)" + "plot_splits(X, y, groups, **cv_args)\n", + "print_split_info(X, y, groups, **cv_args)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Define helper function" + "### Usage in CV" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Split number: 1\n", + "Train true target: [1 0 1 0 1 0 0 1]\n", + "Train predicted target: [0 0 0 0 0 0 0 0]\n", + "Test true target: [1 1]\n", + "Test predicted target: [0 0]\n", + "Accuracy: 0.0\n", + "\n", + "Split number: 2\n", + "Train true target: [0 1 0 1 0 0 1 1 1]\n", + "Train predicted target: [1 1 1 1 1 1 1 1 1]\n", + "Test true target: [0 1]\n", + "Test predicted target: [1 1]\n", + "Accuracy: 0.5\n", + "\n", + "Split number: 3\n", + "Train true target: [0 0 1 1 1 0 1]\n", + "Train predicted target: [1 1 1 1 1 1 1]\n", + "Test true target: [1 0 0 0]\n", + "Test predicted target: [1 1 1 1]\n", + "Accuracy: 0.25\n", + "\n" + ] + } + ], "source": [ - "def test_cv(X, y, groups, **cv_args):\n", - " cv = GroupTimeSeriesSplit(**cv_args)\n", - " groups = np.array(groups)\n", - "\n", - " for train_idx, test_idx in cv.split(X, groups=groups):\n", - " print(\"TRAIN INDICES:\", train_idx)\n", - " print(\"TEST INDICES:\", test_idx)\n", - " print(\"TRAIN LENGTH:\", len(train_idx))\n", - " print(\"TEST LENGTH:\", len(test_idx))\n", - " print(\"TRAIN GROUPS:\", groups[train_idx])\n", - " print(\"TEST GROUPS:\", groups[test_idx])\n", - " print(\"TRAIN GROUP SIZE:\", len(set(groups[train_idx])))\n", - " print(\"TEST GROUP SIZE:\", len(set(groups[test_idx])))\n", - " print(\"TRAIN GROUP MONTHS:\", X.index[train_idx].values)\n", - " print(\"TEST GROUP MONTHS:\", X.index[test_idx].values)\n", - " print()\n", - "\n", - "\n", - "def plot_cv_indices(cv, X, y, groups, n_splits, image_file_path=None):\n", - " \"\"\"Create a sample plot for indices of a cross-validation object.\"\"\"\n", - "\n", - " fig, ax = plt.subplots(figsize=(12, 4))\n", - " cmap_data = plt.cm.tab20\n", - " cmap_cv = plt.cm.coolwarm\n", - " lw = 10\n", - " marker_size = 200\n", - "\n", - " for split_idx, (train_idx, test_idx) in enumerate(\n", - " cv.split(X=X, y=y, groups=groups)\n", - " ):\n", - " indices = np.array([np.nan] * len(X))\n", - " indices[test_idx] = 1\n", - " indices[train_idx] = 0\n", - "\n", - " ax.scatter(\n", - " range(len(X)),\n", - " [split_idx + 0.5] * len(X),\n", - " c=indices,\n", - " marker=\"_\",\n", - " lw=lw,\n", - " cmap=cmap_cv,\n", - " vmin=-0.4,\n", - " vmax=1.4,\n", - " s=marker_size,\n", - " )\n", - " ax.scatter(\n", - " range(len(X)),\n", - " [split_idx + 1.5] * len(X),\n", - " c=groups,\n", - " marker=\"_\",\n", - " lw=lw,\n", - " cmap=cmap_data,\n", - " s=marker_size,\n", - " )\n", - "\n", - " yticklabels = list(range(n_splits)) + [\"group\"]\n", - " ax.set(\n", - " yticks=np.arange(n_splits + 1) + 0.5,\n", - " yticklabels=yticklabels,\n", - " ylabel=\"CV iteration\",\n", - " ylim=[n_splits + 1.2, -0.2],\n", - " xlim=[-0.5, len(indices) - 0.5],\n", - " )\n", - " ax.legend(\n", - " [Patch(color=cmap_cv(0.2)), Patch(color=cmap_cv(0.8))],\n", - " [\"Training set\", \"Testing set\"],\n", - " loc=(1.02, 0.8),\n", - " fontsize=13,\n", - " )\n", - "\n", - " ax.set_title(\"{}\\n{}\".format(type(cv).__name__, cv_args), fontsize=15)\n", - " ax.xaxis.set_major_locator(MaxNLocator(min_n_ticks=len(X), integer=True))\n", - " ax.set_xlabel(xlabel=\"Sample index\", fontsize=13)\n", - " ax.set_ylabel(ylabel=\"CV iteration\", fontsize=13)\n", - " ax.tick_params(axis=\"both\", which=\"major\", labelsize=13)\n", - " ax.tick_params(axis=\"both\", which=\"minor\", labelsize=13)\n", - "\n", - " plt.tight_layout()\n", - "\n", - " if image_file_path:\n", - " plt.savefig(image_file_path, bbox_inches=\"tight\")\n", - "\n", - " plt.show()\n", - "\n", - "\n", - "def plot_cv(X, y, groups, image_file_path=None, **cv_args):\n", - " cv = GroupTimeSeriesSplit(**cv_args)\n", - " cv._n_groups = len(np.unique(groups))\n", - " cv._calculate_split_params()\n", - " n_splits = cv.n_splits\n", + "cv = GroupTimeSeriesSplit(**cv_args)\n", + "clf = DummyClassifier(strategy=\"most_frequent\")\n", "\n", - " plot_cv_indices(cv, X, y, groups, n_splits, image_file_path=image_file_path)" + "scores = cross_val_score(clf, X, y, groups=groups, scoring=\"accuracy\", cv=cv)\n", + "print_cv_info(cv, X, y, groups, clf, scores)" ] }, { "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "## Check train/test split" - ] - }, - { - "cell_type": "code", - "execution_count": 8, "metadata": {}, - "outputs": [], "source": [ - "cv_args = {\"test_size\": 3, \"n_splits\": 1}" + "## Example 2 -- Multiple training groups (with number of splits specified)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", - "TEST INDICES: [ 8 9 10 11 12 13 14 15]\n", - "TRAIN LENGTH: 8\n", - "TEST LENGTH: 8\n", - "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", - "TEST GROUPS: [3 3 4 4 5 5 5 5]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 3\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", - " '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05' '2021-06' '2021-06' '2021-06'\n", - " '2021-06']\n", - "\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -489,50 +306,107 @@ "needs_background": "light" }, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train indices: [0 1 2 3 4]\n", + "Test indices: [5 6 7 8 9]\n", + "Train length: 5\n", + "Test length: 5\n", + "Train groups: [0 1 1 1 1]\n", + "Test groups: [2 2 2 3 3]\n", + "Train group size: 2\n", + "Test group size: 2\n", + "Train group months: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", + "Test group months: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "\n", + "Train indices: [1 2 3 4 5 6 7]\n", + "Test indices: [ 8 9 10 11]\n", + "Train length: 7\n", + "Test length: 4\n", + "Train groups: [1 1 1 1 2 2 2]\n", + "Test groups: [3 3 4 4]\n", + "Train group size: 2\n", + "Test group size: 2\n", + "Train group months: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", + "Test group months: ['2021-04' '2021-04' '2021-05' '2021-05']\n", + "\n", + "Train indices: [5 6 7 8 9]\n", + "Test indices: [10 11 12 13 14 15]\n", + "Train length: 5\n", + "Test length: 6\n", + "Train groups: [2 2 2 3 3]\n", + "Test groups: [4 4 5 5 5 5]\n", + "Train group size: 2\n", + "Test group size: 2\n", + "Train group months: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "Test group months: ['2021-05' '2021-05' '2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] } ], "source": [ - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" + "cv_args = {\"test_size\": 2, \"n_splits\": 3}\n", + "\n", + "plot_splits(X, y, groups, **cv_args)\n", + "print_split_info(X, y, groups, **cv_args)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Check cross-validation split" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Success cases" + "### Usage in CV" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Split number: 1\n", + "Train true target: [1 0 1 0 1]\n", + "Train predicted target: [1 1 1 1 1]\n", + "Test true target: [0 0 1 1 1]\n", + "Test predicted target: [1 1 1 1 1]\n", + "Accuracy: 0.6\n", + "\n", + "Split number: 2\n", + "Train true target: [0 1 0 1 0 0 1]\n", + "Train predicted target: [0 0 0 0 0 0 0]\n", + "Test true target: [1 1 0 1]\n", + "Test predicted target: [0 0 0 0]\n", + "Accuracy: 0.25\n", + "\n", + "Split number: 3\n", + "Train true target: [0 0 1 1 1]\n", + "Train predicted target: [1 1 1 1 1]\n", + "Test true target: [0 1 1 0 0 0]\n", + "Test predicted target: [1 1 1 1 1 1]\n", + "Accuracy: 0.33\n", + "\n" + ] + } + ], "source": [ - "- test_size + train_size \n", - "- test_size + n_splits\n", - "- test_size + n_splits + gap_size\n", - "- test_size + n_splits + shift_size\n", - "- test_size + n_splits + expanding window\n", - "- test_size + train_size + n_splits (full usage of data)\n", - "- test_size + train_size + n_splits (partial usage of data)\n", - "- Groups are not sorted\n", - "- Group names\n", - "- Usage in CV" + "cv = GroupTimeSeriesSplit(**cv_args)\n", + "clf = DummyClassifier(strategy=\"most_frequent\")\n", + "\n", + "scores = cross_val_score(clf, X, y, groups=groups, scoring=\"accuracy\", cv=cv)\n", + "print_cv_info(cv, X, y, groups, clf, scores)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**test_size + train_size**" + "## Example 3 -- Defining the gap size between training and test folds" ] }, { @@ -540,50 +414,9 @@ "execution_count": 10, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", - "TEST INDICES: [8 9]\n", - "TRAIN LENGTH: 8\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", - "TEST GROUPS: [3 3]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", - " '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", - "\n", - "TRAIN INDICES: [1 2 3 4 5 6 7 8 9]\n", - "TEST INDICES: [10 11]\n", - "TRAIN LENGTH: 9\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: [1 1 1 1 2 2 2 3 3]\n", - "TEST GROUPS: [4 4]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", - " '2021-04' '2021-04']\n", - "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", - "\n", - "TRAIN INDICES: [ 5 6 7 8 9 10 11]\n", - "TEST INDICES: [12 13 14 15]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 4\n", - "TRAIN GROUPS: [2 2 2 3 3 4 4]\n", - "TEST GROUPS: [5 5 5 5]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", - "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", - "\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -592,20 +425,59 @@ "needs_background": "light" }, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train indices: [0 1 2 3 4]\n", + "Test indices: [8 9]\n", + "Train length: 5\n", + "Test length: 2\n", + "Train groups: [0 1 1 1 1]\n", + "Test groups: [3 3]\n", + "Train group size: 2\n", + "Test group size: 1\n", + "Train group months: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", + "Test group months: ['2021-04' '2021-04']\n", + "\n", + "Train indices: [1 2 3 4 5 6 7]\n", + "Test indices: [10 11]\n", + "Train length: 7\n", + "Test length: 2\n", + "Train groups: [1 1 1 1 2 2 2]\n", + "Test groups: [4 4]\n", + "Train group size: 2\n", + "Test group size: 1\n", + "Train group months: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", + "Test group months: ['2021-05' '2021-05']\n", + "\n", + "Train indices: [5 6 7 8 9]\n", + "Test indices: [12 13 14 15]\n", + "Train length: 5\n", + "Test length: 4\n", + "Train groups: [2 2 2 3 3]\n", + "Test groups: [5 5 5 5]\n", + "Train group size: 2\n", + "Test group size: 1\n", + "Train group months: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "Test group months: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] } ], "source": [ - "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", + "cv_args = {\"test_size\": 1, \"n_splits\": 3, \"gap_size\": 1}\n", "\n", - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" + "plot_splits(X, y, groups, **cv_args)\n", + "print_split_info(X, y, groups, **cv_args)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**test_size + n_splits**" + "### Usage in CV" ] }, { @@ -617,66 +489,43 @@ "name": "stdout", "output_type": "stream", "text": [ - "TRAIN INDICES: [0 1 2 3 4]\n", - "TEST INDICES: [5 6 7 8 9]\n", - "TRAIN LENGTH: 5\n", - "TEST LENGTH: 5\n", - "TRAIN GROUPS: [0 1 1 1 1]\n", - "TEST GROUPS: [2 2 2 3 3]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 2\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", - "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", + "Split number: 1\n", + "Train true target: [1 0 1 0 1]\n", + "Train predicted target: [1 1 1 1 1]\n", + "Test true target: [1 1]\n", + "Test predicted target: [1 1]\n", + "Accuracy: 1.0\n", "\n", - "TRAIN INDICES: [1 2 3 4 5 6 7]\n", - "TEST INDICES: [ 8 9 10 11]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 4\n", - "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", - "TEST GROUPS: [3 3 4 4]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 2\n", - "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05']\n", + "Split number: 2\n", + "Train true target: [0 1 0 1 0 0 1]\n", + "Train predicted target: [0 0 0 0 0 0 0]\n", + "Test true target: [0 1]\n", + "Test predicted target: [0 0]\n", + "Accuracy: 0.5\n", "\n", - "TRAIN INDICES: [5 6 7 8 9]\n", - "TEST INDICES: [10 11 12 13 14 15]\n", - "TRAIN LENGTH: 5\n", - "TEST LENGTH: 6\n", - "TRAIN GROUPS: [2 2 2 3 3]\n", - "TEST GROUPS: [4 4 5 5 5 5]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 2\n", - "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", - "TEST GROUP MONTHS: ['2021-05' '2021-05' '2021-06' '2021-06' '2021-06' '2021-06']\n", + "Split number: 3\n", + "Train true target: [0 0 1 1 1]\n", + "Train predicted target: [1 1 1 1 1]\n", + "Test true target: [1 0 0 0]\n", + "Test predicted target: [1 1 1 1]\n", + "Accuracy: 0.25\n", "\n" ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ - "cv_args = {\"test_size\": 2, \"n_splits\": 3}\n", + "cv = GroupTimeSeriesSplit(**cv_args)\n", + "clf = DummyClassifier(strategy=\"most_frequent\")\n", "\n", - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" + "scores = cross_val_score(clf, X, y, groups=groups, scoring=\"accuracy\", cv=cv)\n", + "print_cv_info(cv, X, y, groups, clf, scores)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**test_size + n_splits + gap_size**" + "## Example 4 -- Expanding the window size" ] }, { @@ -684,48 +533,9 @@ "execution_count": 12, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TRAIN INDICES: [0 1 2 3 4]\n", - "TEST INDICES: [8 9]\n", - "TRAIN LENGTH: 5\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: [0 1 1 1 1]\n", - "TEST GROUPS: [3 3]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", - "\n", - "TRAIN INDICES: [1 2 3 4 5 6 7]\n", - "TEST INDICES: [10 11]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", - "TEST GROUPS: [4 4]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", - "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", - "\n", - "TRAIN INDICES: [5 6 7 8 9]\n", - "TEST INDICES: [12 13 14 15]\n", - "TRAIN LENGTH: 5\n", - "TEST LENGTH: 4\n", - "TRAIN GROUPS: [2 2 2 3 3]\n", - "TEST GROUPS: [5 5 5 5]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", - "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", - "\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -734,20 +544,50 @@ "needs_background": "light" }, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train indices: [0 1 2 3 4 5 6 7 8 9]\n", + "Test indices: [10 11]\n", + "Train length: 10\n", + "Test length: 2\n", + "Train groups: [0 1 1 1 1 2 2 2 3 3]\n", + "Test groups: [4 4]\n", + "Train group size: 4\n", + "Test group size: 1\n", + "Train group months: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", + " '2021-03' '2021-04' '2021-04']\n", + "Test group months: ['2021-05' '2021-05']\n", + "\n", + "Train indices: [ 1 2 3 4 5 6 7 8 9 10 11]\n", + "Test indices: [12 13 14 15]\n", + "Train length: 11\n", + "Test length: 4\n", + "Train groups: [1 1 1 1 2 2 2 3 3 4 4]\n", + "Test groups: [5 5 5 5]\n", + "Train group size: 4\n", + "Test group size: 1\n", + "Train group months: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", + " '2021-04' '2021-04' '2021-05' '2021-05']\n", + "Test group months: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "\n" + ] } ], "source": [ - "cv_args = {\"test_size\": 1, \"n_splits\": 3, \"gap_size\": 1}\n", + "cv_args = {\"test_size\": 1, \"train_size\": 4}\n", "\n", - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" + "plot_splits(X, y, groups, **cv_args)\n", + "print_split_info(X, y, groups, **cv_args)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**test_size + n_splits + shift_size**" + "### Usage in CV" ] }, { @@ -759,56 +599,36 @@ "name": "stdout", "output_type": "stream", "text": [ - "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", - "TEST INDICES: [8 9]\n", - "TRAIN LENGTH: 8\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", - "TEST GROUPS: [3 3]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", - " '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", + "Split number: 1\n", + "Train true target: [1 0 1 0 1 0 0 1 1 1]\n", + "Train predicted target: [1 1 1 1 1 1 1 1 1 1]\n", + "Test true target: [0 1]\n", + "Test predicted target: [1 1]\n", + "Accuracy: 0.5\n", "\n", - "TRAIN INDICES: [ 5 6 7 8 9 10 11]\n", - "TEST INDICES: [12 13 14 15]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 4\n", - "TRAIN GROUPS: [2 2 2 3 3 4 4]\n", - "TEST GROUPS: [5 5 5 5]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", - "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", + "Split number: 2\n", + "Train true target: [0 1 0 1 0 0 1 1 1 0 1]\n", + "Train predicted target: [1 1 1 1 1 1 1 1 1 1 1]\n", + "Test true target: [1 0 0 0]\n", + "Test predicted target: [1 1 1 1]\n", + "Accuracy: 0.25\n", "\n" ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ - "cv_args = {\"test_size\": 1, \"n_splits\": 2, \"shift_size\": 2}\n", + "cv = GroupTimeSeriesSplit(**cv_args)\n", + "clf = DummyClassifier(strategy=\"most_frequent\")\n", "\n", - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" + "scores = cross_val_score(clf, X, y, groups=groups, scoring=\"accuracy\", cv=cv)\n", + "print_cv_info(cv, X, y, groups, clf, scores)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**test_size + n_splits + expanding window**" + "## API" ] }, { @@ -820,912 +640,117 @@ "name": "stdout", "output_type": "stream", "text": [ - "TRAIN INDICES: [0]\n", - "TEST INDICES: [1 2 3 4 5 6 7 8 9]\n", - "TRAIN LENGTH: 1\n", - "TEST LENGTH: 9\n", - "TRAIN GROUPS: [0]\n", - "TEST GROUPS: [1 1 1 1 2 2 2 3 3]\n", - "TRAIN GROUP SIZE: 1\n", - "TEST GROUP SIZE: 3\n", - "TRAIN GROUP MONTHS: ['2021-01']\n", - "TEST GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", - " '2021-04' '2021-04']\n", + "## GroupTimeSeriesSplit\n", "\n", - "TRAIN INDICES: [0 1 2 3 4]\n", - "TEST INDICES: [ 5 6 7 8 9 10 11]\n", - "TRAIN LENGTH: 5\n", - "TEST LENGTH: 7\n", - "TRAIN GROUPS: [0 1 1 1 1]\n", - "TEST GROUPS: [2 2 2 3 3 4 4]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 3\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", - "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "*GroupTimeSeriesSplit(test_size, train_size=None, n_splits=None, gap_size=0, shift_size=1, window_type='rolling')*\n", "\n", - "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", - "TEST INDICES: [ 8 9 10 11 12 13 14 15]\n", - "TRAIN LENGTH: 8\n", - "TEST LENGTH: 8\n", - "TRAIN GROUPS: [0 1 1 1 1 2 2 2]\n", - "TEST GROUPS: [3 3 4 4 5 5 5 5]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 3\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", - " '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05' '2021-06' '2021-06' '2021-06'\n", - " '2021-06']\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "cv_args = {\"test_size\": 3, \"n_splits\": 3, \"window_type\": \"expanding\"}\n", - "\n", - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**test_size + train_size + n_splits (full usage of data)**" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TRAIN INDICES: [0 1 2 3 4]\n", - "TEST INDICES: [ 5 6 7 8 9 10 11]\n", - "TRAIN LENGTH: 5\n", - "TEST LENGTH: 7\n", - "TRAIN GROUPS: [0 1 1 1 1]\n", - "TEST GROUPS: [2 2 2 3 3 4 4]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 3\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02']\n", - "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", + "Group time series cross-validator.\n", "\n", - "TRAIN INDICES: [1 2 3 4 5 6 7]\n", - "TEST INDICES: [ 8 9 10 11 12 13 14 15]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 8\n", - "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", - "TEST GROUPS: [3 3 4 4 5 5 5 5]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 3\n", - "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05' '2021-06' '2021-06' '2021-06'\n", - " '2021-06']\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "cv_args = {\"test_size\": 3, \"train_size\": 2, \"n_splits\": 2}\n", - "\n", - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**test_size + train_size + n_splits (partial usage of data)**" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TRAIN INDICES: [1 2 3 4 5 6 7]\n", - "TEST INDICES: [ 8 9 10 11]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 4\n", - "TRAIN GROUPS: [1 1 1 1 2 2 2]\n", - "TEST GROUPS: [3 3 4 4]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 2\n", - "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04' '2021-05' '2021-05']\n", + "**Parameters**\n", "\n", - "TRAIN INDICES: [5 6 7 8 9]\n", - "TEST INDICES: [10 11 12 13 14 15]\n", - "TRAIN LENGTH: 5\n", - "TEST LENGTH: 6\n", - "TRAIN GROUPS: [2 2 2 3 3]\n", - "TEST GROUPS: [4 4 5 5 5 5]\n", - "TRAIN GROUP SIZE: 2\n", - "TEST GROUP SIZE: 2\n", - "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04']\n", - "TEST GROUP MONTHS: ['2021-05' '2021-05' '2021-06' '2021-06' '2021-06' '2021-06']\n", - "\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA+oklEQVR4nO3dd5xU5d3+8c9FlbIUKYJKsaCJooCgiRqfGDXGXuJjkJgCdo0lGolGTexRoz9jYjRGjb08GkussUuiMZiACCKKQgRFmojAwiKw7Pf3xzmj47hldpnZ2V2u9+s1r5k59ZozW+Y7933uo4jAzMzMzMzM1l2rUgcwMzMzMzNrKVxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgLrDMzMzMzMwKxAWWmZmZmZlZgbjAMrMWT9Ihkp6R9LGk1ZI+lPSApH1KnS1D0kBJkccts9zJjZitk6SLJU2XtFLSAkl/l3R0AfcxS9JVhdpe1nYPlPRPSUskLZP0pqQbJHWu53ZGp8e9c/o88z4ckLXMzyXtXthXYGZmzU2bUgcwMysmSb8FTgXuAP4IfAwMAI4A/iZpy4iYWcKIGfOAnbOebw7cDfwEeK2a5d5rvGg8CAwDLgGmAr2B/wH2A/5coH0cSvLeFIykUcA9wJ9IsgewPfBjoBuwfB02n3kf3s6a9nPgD8C4ddiumZk1c/KFhs2spZJ0MPBXYExE3FbN/AOBiRExt5p5HSJiZdFD1kDSYOAN4FsRMa6EOQYB7wDfi4i/5MxTrOM/kWIeZ0n/BJZExP7VzKtXdkmjgVuBsoiotjCTtAj4Q0Rc0LDEZmbWEriLoJm1ZD8F/lNdcQUQEY9liqu0u9cZkq6R9BFJcYOknpJuT7sXVkgaJ2lE9naq67In6YL0A3fmeaaL2Y6SXkq72r0j6dD6vqjc/aWZHpA0RtJ7kpZLulNSe0k7Sfp3Om2cpP4529pA0m8kfSBplaTJkvbLWqRbej+/muP3hQJFUn9J/ydpcXqsnpa0ddb8TLe6IyXdIWkJ8Fg670tdBCXtlnZFrEiP/02SyrLmd5N0s6S5kj6V9L6km3Kyfyl3bvas9/53afYlkq6V1K66dXNeywGZ/EAP4Pys7py717S+mZm1XC6wzKxFktSGpAvXM/VYbSzQF/ghSbdCSFrAvgOcCYwk+bv5oqQtGxjtPuAR4LskRdxfJA1p4LayfZ2k69spJF3VvgdcC9wE/A74AUm3wxtz1nsAGA38GjgQ+A/wqKSh6fzpwArgGkl7S9qgup1L2hB4GdgaOCHdfyfgOUkdcha/CigHDk/3W932dgWeIymQ/pekWN6PpBUp42rgG8DpJO/ROSTdADNeA0ZJOlnSxtXtJ8vPgE2BI0m6Ex4HXFrHOtkOBZaSdJncOb29VusaZmbWIvkcLDNrqXoA7YEPsidKEtA6a9LarNaMeRExMmvZfYBdgd0j4u/ptBeAWSTF2PENyHVzRFyVbutpYBrwC5JzwtZFZ+DgiFiabnt34FjgmxHxj3TaxsB1kjpGRIWkPYH9yXp9wDOStgLOBQ6PiGWSjiUp1J4G1kgaD9yZvpbMsTudpKAaGhGL0/39k+RYHQVcl5V1fET8pI7XcznwSs778SHwvKTBETEV2Am4LiLuy1rvrqzH5wDbkRSa10p6j6Rg/k1E5LZslaevt4rk3Lz2wLmSLsu8ntpExCRJlcCciBhf1/JmZtZyuQXLzFq63PNsfgasybplf9B/MmfZnYCFWcUHEbECeJyk5aQhHs7aVhVJa9ZODdxWtgmZ4io1A1hN0qqUPQ0g05qzF0kL0T8ltcncgOeBz7pBRsS9JAODHAX8H7AVSUvYPVnb3gt4FliWtZ1yYGL2tlJP1PZCJHUkaQG6PyfXyyTv2fB00deBsZJOSovCL4iID9Jl9wL+H7CYpBCcImnTnMUfSd+PjIeADsDg2rKamZnlcoFlZi3Vx8Aqkm5f2e4EdkxvuRbkPO8LLKxhuQ0bmCt3ewvT/ayrJTnPVwPlOUXD6vQ+082vJ9CHLxaca4ALgH7ZG4uIjyPi1oj4UTrvVuCIrO6NPUm6UOZu61u52+LLxzlXd5JWxutztrUKaJu1vZNJWqR+BUyX9K6kL7QERsTaiHg+Is6MiBEkXQk3JCm0s1X3vkBh3hszM1uPuIugmbVIEVEp6V/A3iQfwDPTF5B+wE96C35xtZzn80iGJM+1EUlrSMYqIHdAhO41ROvNF4cj753upxQWAx8Ch9RnpYhYo2T4+zHAV4DJ6bYeBS6uZpXy3E3UsYsl6TIX8OVWRYC5aY4lJOfKnSppe5Jzz+6WNCUiptWQ/RlJk9Pc2XLf58zzUr03ZmbWTLkFy8xasmuAr0n6YQPXfxXoLel/MhPS7mv788Wud3OAr2Yt0wrYs4ZtHpqz3MHAvxuYb109T9KCtTwiJuTe0oxl1QxSATAovV+Qta1tgTer2db0+oRKu2GOB7auLld1w+pHxBSS8+JakRZPkr5UHKeDdGzKl1vRDk7fj4zvAitJrvuVr9V83jpoZmbrKbdgmVmLFRGPSLoGuE3St0iGBF9EMgDG3uliNV5sNiKelvQKcJ+ks0lans4kOTfnyqxFHwZ+ImkS8F/gGKBLDZs9RtJqkg/uxwBbAqMa9grX2bMkA1c8K+kK4E2S3EOBDSLiFySjAj4q6RbgFaAinX8uyTlQmULzapKRCl+QdC1Jy9hGwDeBl9PzuOrj5yQDWlSRjHRYDvQnKW7PjYh3JL1McuynkrR4HUsy4mGmYH1a0tsk7/sHJMXkySSti3/K2V8ZyYiON5EUir8kGUCjzgEusrwN7C/pKZKfq+kRkdt6Z2ZmLZwLLDNr0SLidEn/AE4iGUK7DPgI+BewX0T8rY5NHEIyQMI1JK0T/wb2iIgZWctcSNKl7BKSVow/kBQr1Y2UdwTw23TZD4CRETGpIa9tXUVESPouyWh7PyUpYBaTFE7XpovNBG4mOXfpRJLi8n3gFuCKiKhMt7VI0tdJhjb/Lck1qOaRFGBTGpDt5bTl8EKS8+ZaA7OBp/i89elfJEPMDwTWApOAfSNiTjr/NyTH+wqS9+cjkqHTvxERua2G/49kGPt7SVrB/pwel/oYSzJa4hNAR5Lzz8bVcxtmZtbMqR4XsjczswaSNJpkYIiyiKix1cwan6QATomIP5Q6i5mZNX8+B8vMzMzMzKxAXGCZmZmZmZkViLsImpmZmZmZFYhbsMzMzMzMzArEBZaZmZmZmVmBuMAya4YkDZU0XtIKSbfmzAtJu6eP20m6QNLQImQoyrYljZP0QIG3uXs6Ulx919tL0n2SZkuqkDRV0smSWq9rBklbpcevW323Vcd+Zkm6qpDbzGOft0maUOBtDkx/lgfWc70dJd0qaUb6nk2XdH56geFGydAY0p+dRVnPd0+zDk6fN+j3s9jHXdIhktakv1Nn12cfZmbNha+DZdY8XQJsAhwJvFHLcu2A84FZJNc2KqRibfskYE0Bt7cujiO5ntF5JNes+gbJ9ZI2A362jtveiuT43QYsWcdtZTuU5ILIjelikutjNQUjgS1Irn31LrA9Sb7tgcNKmKvYXgN2JrluGRT3d786+R73vwPfBo4GLpN0b0TMboR8ZmaNxgWWWfO0FfB4RPy11EEKLSKmlTpDlpMiYlHW83GSOgKnSzonIlY1RghJG0TEp/ksW4qLFkfEzLqXajSXV/OefQr8SdKAlvphPiKWAeNLGCGv4x4Rn6TzFgE/ALYmuYC0mVmL4S6CZs1TO2BFHsuVp/e3pt1+Puv6I2kDSb+R9IGkVZImS9ove2VJB0mamHZF/ETSq5K+Wde2ayNpW0lPSVqcbvctST/Jmv+FLoJZ2869jc5aZjdJf0+7Jn0s6SZJZXkcn1rlfGDMmARsAGzY0O2mXTgfS5++l76eWem80enzndJjsRIYm867XNIbkpZLmiPpbkl9crb9hS6Cme57kr4taUp6zF+WtG098m4q6X5JCyWtlDRT0sW5+8jJUN17dkHWMoMlPSGpPL39Jfe1NEQt7xnAxuuy7azuc9+T9CdJS9P34UJJef8/lXS0pGnpsVyU/uxum7OP70u6Mz02CyWdX8c2v9BFkNp/93+hpCvfp5IWpL+P63TsG3DcMxfbbrcu+zUza4rcgmXWwkSEsp7uAbxA0qXwiXTavPT+AWAnkm5EM4HvAY9KGhERr0vaIl3mdyQf8DcAhvN5YVHbtmvzGPAWybfXq0i+we5Sy/I75zz/PnAyMANA0q7Ac8Bfgf8FegCXA93T50TEOCD7uJAWNOMiYnQemXPzLAEW1melnAyvAWcCVwHfJTluua1h9wLXAxfyeRfC3sCvgblAL5Juii9IGhwRVbXsvj9wJXApsDLd732Stov8rtVxB0kXwOPSLJsDX6ll+UOB9lnPv5XmfgdA0pbAP4EJJD8HbUi6kz0maadIzOLL79k4gIjYPY/M2XYGqvi8+1xeqsuQ+g3wIMnP157Ar4A3gfvr2qak/wFuSNf5F8nP/s5A15xFrwQeT/fxP8D5khZFxHV5xq/291PSj4BzgLPSzD3SZTtB9a+5sY+7mVlz5wLLrHnqRn4tWP9J72dGxGfdhyTtCewP7B4Rf08nPyNpK+Bc4HBgGFAeEWOztvdkXduujaSeJOcvHRwRmXPHnq9tnZzcw4FjgQsj4uV08uXAKxExMmu5D4Hn08Jjag2brgTW5pM7a7vbACcCV0REvdbNFhHLJE1Pn05KP9Tm+n1E/C5nvaOysrQm+YA+h+TcsH/UsssNgV0j4t103VbAwyTF7dt5RN4JGBURmVa3cbUtnN1NUdIA4Azgtoi4J518PjAf2DciVqfLTUmz7MfnBUGueh/ztGXmPODOiKhXUVyLf0RE5hy8ZyXtQ1Io11lgkRzLKRFxWda0R6tZ7s2IOD59/LSk3sA5kv5YRzGdUdPv/k7AMxFxfdayD9WxrWIc94r0PrewNDNr9txF0KwZkdRJ0lEkH0omrsOm9iL5gPtPSW0yN5JiZ0S6zBtAV0m3S9pbUqd1Cp9YTDJYxA2SRqYfGvMiqRfJB8HngIvSaR1JviW/P+d1vEwyUMbwmrYXEVtGxNH12H93klaLKSStMcX2pSJD0r6SXpG0lKRAnJPO2qqObc3KFFepzHlum+aZ5XWSAQlGS+qf5zpI6kBSyM0mKUwz9kqnV2W9Z++RDMgwInc7GRGxZ0TsWY/9tyMpepYDp+e7Xh6eyXk+jfody2GSfivpf9KM1Xk45/lDJF3t8t1PbfvfL+3WuJPyGBGzSMf9I+B9YLSkjevTxdLMrKnzHzSzZiI9f2I58Gfg2oio7lvvfPUE+pAUIdm3C4B+ABExHTiYpDvYk8AiSfekhU6DpN+8701S3N0CzJf0kqRhta2XfgC/H1gN/CCrW1t3oDVJV7rs17EKaJt5LetKyVDTj5B0ezso0+pSZAtyMuxI0tIxB/ghSWH59XR2XUOQL8l5nsmf79DlI0m68/0WmC3p9bQVtC43krwHh+UM0tGTpIta7s/f5hTuPRNJ18Ztgf3SwRUKZUnO89XkeSwj4jlgDEm3v3Ekv1fXVfMFRm6rT+Z533ol/bJbSLoIfg94FVgg6ZJ8Cq185Hvc09/h7wE7AB+SdJk0M2sR3EXQrPmYC+xG8qHkJEl3R8SrDdzWYpIPNYfUtlBEPAE8IakrSZfCa4BrgSMauF8i4m3gMEltSV7PFek+Nq2l69NVwI7A1yNiadb0JUCQFIZPfnk15jY0Z0b6wfMeYBuSbnYL6lilUHLPjTqU5Fv/kZkCM+1+V/wgER+StDS0IunidgHJ+Xr9I6LaIeEl/RQYBexTzch9i0laaG6uZtXqBktoiGtIviD4dvoz12RExO3A7emXFd8lKVzLgezrQuW27mae53OeY237rkr391tJ/Ugu9XApSeF+w7psO3UN+R/335F82fIjPh8Qw8ys2XOBZdZMpK0mL0saT3INmb1JvoGuTU0tFc+TDJCwPJ8Pn2lRc4+SEQQzg07UtxUkd5trSAZouJqkgOlG8sH7CyT9EDgNOCL3fKqIWJEej60j4qKG5MjD9cA+wF5pq16h1Pf4dQDW5AxKcWQB89Qp/XA+XtKFwCvAAKq55pakb5EM0nBO2mKT63mSFo6JeQ6yUS+SfkEyEMr3ss7Va3Ii4iOSYcy/S1LAZzsU+GPW88xgKHPIT50/XxHxAXC5pDHV7L/e6nPc0y63XwOOSb/IMTNrMVxgmTUzEVGp5BoytY28l1l2taT3gO9Jmgp8SnIO0bPA0yQn6F9BMppYF2AosEFE/ELS8STF1FMkLUGDSAa/uKO2bdfWfU7S9qQj2AH/JenidxYwOSKqK662IOlm9jeSrmlfz5o9M/2A+nOSAS2qSEY9LCcZNW9/4NyIeKeGLDOAv9d2Hpakc0hGzruM5Hyh7P1PS689hJLhx8/PGcGxLpli7XhJ/wdUZA38UZ1ngZ9KuoZkJMZdSEbgK6q09fJpkvf9HZJukj8jaXl4q4bl7wemAv/IOWZzImIOSQvYv0laLm8habXahOQCtLelIy5Wl+V5SM4JqiXv90nOkbsN+LCGnxmUDPN/K7BZDYOMFEVanG5I2j2QZDCZb/LF1iuAbSX9ieS8v/8h+VLltDwHuKjtd/9aki8yxgNLSUZ4HETye1hT5oId9yyZv1+FGnjEzKzJcIFl1jwF1Q8fXZ0TSIqa50g+HG8WEbPSb83PAX5KUpAsJjkB/tp0vSnAQcDVJB8I5wE38cVzJb60bZKBCmoyn+TconNJTthfArxIzR/u+pF8A79vess2huTD+MtKhr6+ELiT5Jys2SSFYW3d+dqky9Zm7/T+F+kt27f4fDS9jiTd9/IWEbMlnQmcCpxC0jIxsJbln5R0VrrssSQjCB5AOvR5EX1KMuDJaSTvRwXJh/O9I2JlNct3JznHqmeaMduFwAUR8U76AfwSkgK6A0mX1edJh9+vQT7nCWXes9HpLdsYkgIAkvdsNV8+n6rY/kMy8MMRQBnJz+oFJN3lsv2c5P19kOQ9uBj4Qz33Vd3v579Ifn6OJ/ndmgEcG7VftLyQxz0j8/er4C2YZmalpiL0zjCzIpM0E3gyIk4pdRYDSX8HXoiIC0udxfIj6XagKiLGlDpLtnQwm/eAAyPi8RLHKRpJmUsE7BsRT5U6j5lZIbkFy6x5mgN8Q9LGwPx8uw1Z4aUjHA4mvaixNRs7A4eVOsT6Jh1lsCPJOWaQ/zllZs3CxIkT27Vq1erE1q1bj4mIruTf28Sah5C0dO3atbdWVVX9cfjw4dWeFuECy6x5uhq4m6Rb1e18uUtOSaSjzNV4+YeIqGzEOI0ifU09Sp2joep6z4C1xRiIotQioq5rhzVIWnDXstuGX6C6hTiYz6/x9WAtFwI3a5batGlzU5cuXXbdeOONV7Rr1+7j5DsFaykigtWrV7edO3fuKcuWLdsB+HF1y/k6WGbNUEQ8QnKOy2CS8zeailv48rWNPrul3Z+safkVtbxnJAMwWP5qO5bP17VyRMyKCLXg7oHjSAb22Cgi3OprLdE3BgwYsLR9+/ZrXFy1PJJo3779mgEDBiwFvlHTcm7BMmum0gu3vlnqHDkuoPYT8df5ulRWcDcCtX2YL+TQ9OuDHWuZV95oKZqoiFhCMpiOWUvVulWrVi2u1d++KH2PaxwAyINcVKNnz54xcODAUscwMzMzsxKaOHHioojole/ykydPnjVkyJBCXTDdmrDJkyf3HDJkyMDq5rkFqxoDBw5kwoQJpY5hZmZmZiUkaXapM1jz4wLLzMzMzKyIfn3v6iEVq4r/ubtjeyrPGdVucrH3k+uPf/zjhtdcc02f6dOnTyvG8s2NB7kwMzMzMyuixiiu6rOfjh07Dsvc2rRps0ObNm12yJ5W3/2eeOKJi+tTLNV3+cY0ffr0dpKGz5w5s21Dt+EWLDMzMzOz9UhFRcWkzOORI0cOqKys1IMPPjirumVXrVql9u3be9CGenALlpmZmZmZAbDTTjttfdRRR/Xba6+9tujcufOwCy+8cKOZM2e23W233QZ17959SFlZ2dDhw4dv/dJLL3XMrPP73/++R//+/Qdnb+PYY4/d9Dvf+c4WnTp1GtavX7/Bd911V7eGLl9VVcXZZ5/dZ6ONNtq+a9euQ48++uh+O++881ZnnHHGxtW9hpUrV2rUqFEDNtxwwyGdO3ceNmDAgMG33HJL98z8p556qvPw4cO37tq169B+/foNPv/88zeqqqoCYMSIEdsADB48eHDHjh2HjR07tm99j6ELLDMzMzMz+8z999/f89RTT124bNmySb/4xS8WVlVV6YQTTlj4/vvvvzFv3rzJ22+/fcXIkSO3WLVqVY0X+3rggQd6nHnmmfOXLVs26Zhjjll44oknDiwvL6+x9qht+euvv77HTTfdtNFDDz307sKFCyf37dt39X/+85/ONW3ruuuu6/H66693mjZt2tTly5dPev7556cPGTJkJcDEiRM3OOywwwadfvrpCz7++OPXH3300Rk333xz7+uvv74HwIQJE6YBTJ06dWpFRcWkK6+8cl59j58LLDMzMzMz+8y+++77yUEHHVTeqlUrysrKqgYNGrT6yCOPXFpWVlbVuXPnuPrqqz+cN29eu6lTp7avaRsHHHDAJ9/+9rdXtG7dmtNPP33R8uXLWzd0+XvuuafHD3/4w4923XXXle3bt4+LLrpoQe/evdfUtK127dpFRUVFq9dff73DmjVr2HLLLdcMHz78U4Df/e53vffbb79PfvCDHyxp06YNw4YN+/SYY45ZeM899/RYl2OWzedgmZmZmZnZZwYMGLAq+/m8efPanHTSSZuOHz++rLy8vI2kAJg/f36NtUTfvn0/K4C6dOlSBbBs2bIaL85b2/Lz589vO2DAgNWZ+a1ataJv376rv7yVxIknnvjxggUL2p555pn9Zs+e3X7nnXcuv/rqq+cMHjx41fvvv99u/PjxXcrKyrpllo8I9enTp8bt1ZdbsMzMzMzM7DOtWn2xRDj99NM3WbBgQdvx48e/vXz58knvv//+FEgKk8bI06dPnzWzZ89ul3leVVXFvHnz2tW0fNu2bbn00kvnT5069a333nvvjQ4dOlSNHj16IMCmm266+vDDD19UXl7+eua2fPnySTNmzHgTvvzaG8IFlpmZmZmZ1ai8vLx1hw4dqnr16lW5dOnSVqeccsqmjbn/UaNGfXzXXXf1euWVVzqsWrVKF1544UYLFy6scRj1Rx99tOyll17quGrVKnXq1KmqU6dOVa1btw6A0047beFjjz224T333NN11apVWrNmDRMnTtzgiSee6AxJS1qrVq2YNm3aBg3N6wLLzMzMzKyIOransjnv59e//vWHH3/8cdsePXoM3XbbbbfdZZddlrduXWNvv4L7yU9+8vGYMWMWHnLIIYN69+49ZM6cOe2GDBmyon379lXVLT9v3ry2o0eP3qx79+5D+/TpM+SDDz5od/PNN88G2HHHHT994IEH3r322ms36tOnz/Y9e/YcOnr06M0yBVvnzp1j7NixH44ZM2bzsrKyoWeddVaf+uZVhIe1zzVixIiYMGFCqWOYmZmZWQlJmhgRI/JdfvLkybOGDBmyqJiZDNauXUvfvn23v+iii+accMIJi0uRYfLkyT2HDBkysLp5bsEyMzMzM7Mm7cYbb+xeUVGh8vLyVmecccbGn376aavDDjtsaalzVccFlpmZmZmZNWl/+tOfem+00UZDNt544+1feumlLg899NC7vXr1WlvqXNXxMO1mZmZmZtakTZw4cXqpM+TLLVhmZmZmZmYF4gLLzMzMzMysQFxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgHkXQzMzMzKyIllx95pBYuaLon7vVoVNltzOumlzs/dTHlltuue1ZZ50199hjj/2k1FkaiwssMzMzM7Miaoziqj776dix47DM49WrVwugXbt2kZlWUVExqb77nj59eruvfOUr282YMWPKFltssSYzfcaMGW/Wd1uN5bDDDhvYpk2buO+++2YXcrsusMzMzMzM1iPZBdTIkSMHVFZW6sEHH5xVwkgtis/BMjMzMzMzAN599912++yzz+Y9e/Yc0qtXr+1HjRo14JNPPmkFUFVVxSmnnLJJ7969t+/UqdOwTTbZZLtLL720N8CIESO2ARg8ePDgjh07Dhs7dmxfgE022WS766+/fkOAxx9/vKxNmzbDb7rppu79+vUbXFZWNnS//fbbPLN9gClTprTfcccdt+7cufOwrbfeepuLL764t6ThNeX961//WvbVr351m86dOw/r3r37kF122WWrzLzy8vJWxx133KabbLLJdl27dh262267DZo6dWp7gPPOO2+jRx55ZMMHH3ywR8eOHYd17NhxWGVlZUGOoQssMzMzMzOjoqJCe+6551Zf+cpXPp01a9aUadOmvTl37ty2xx13XH+Av/71r13uv//+Hq+88spbK1asmPTvf//7rd13370cYMKECdMApk6dOrWiomLSlVdeOa+6faxdu5Znn322y9SpU6dNmzZt6ptvvtnx8ssv7w2wZs0aDjrooEHbbrttxfz5819/+OGHZ9xxxx29ast83HHHbXbCCScsWLZs2aS5c+dOOeeccz7b75FHHjng3Xff3WD8+PFvLViwYPKIESNWHHjggVuuWrVKl1xyyYKDDz548WGHHfZxRUXFpIqKiklt2hSmc58LLDMzMzMz47777usWEVxzzTVzO3fuHL169Vp7ySWXzH3kkUc2rKyspF27drF69Wq9/vrrHSoqKrTJJptU7rrrrivru59rrrnmw65du1b169evcp999lny2muvdQJ44YUXOs+dO7fdH/7whzmdO3eObbbZZvVJJ520oLZttW3bNmbOnNl+zpw5bTp06BAHHHBAOcC8efPaPPbYYxveeOON7/fr169ygw02iKuuumruokWL2o4bN65Tw45QflxgmZmZmZkZ//3vf9vNmzevXVlZ2dDMbb/99ttKEh988EHbAw44oPzcc8/98LLLLuvbu3fvobvuuuugf/zjHx3rs4/WrVuz8cYbf9YXr1OnTlUrVqxoDfD++++33XDDDSs7d+782YAbm2222aratvfAAw/MmDlz5gZDhgzZdostttj2oosu6g3wzjvvtAPYYYcdtsm8lm7dug2trKzUrFmz2tUnc315kAszMzMzM2PAgAGrBw4cuKq2kf/OPPPMRWeeeeai8vLyVmPHjt145MiRW8ybN++NVq3Wvd2mf//+az755JM2y5cvV6bIqqsY2nnnnVc+8cQT/62qquKZZ57pfMghh2w1dOjQlcOHD18JMH369KnZBV22QmSudrtF2aqZmZmZmTUrI0eOXLpmzRqdffbZfT755JNWVVVVvPfee23vuOOObgAvvvhix6eeeqrzypUr1aFDh6qysrK1mSKlb9++a1q1asW0adM2aOj+99hjj+V9+/Zdfeqpp25aUVGht99+u93111+/UU3Lf/rpp7r22mt7zJs3r02rVq3o0aNHpaRo3bp1bLLJJpUHHnjg4qOPPrr/e++91xZg0aJFre+4445uS5cubQWw0UYbrZk9e3b7tWvXNjRytVxgmZmZmZkVkTp0KszwdEXeT1lZWdXzzz8//a233uqw9dZbD+7SpcuwPfbYY6tJkyZ1BCgvL299xhln9OvZs+fQ7t27D33hhRe63HXXXTMBOnfuHGPHjv1wzJgxm5eVlQ0966yz+tR3/23btuXhhx+eMWXKlI69evUaevDBB285cuTIj9u2bRs1rfPAAw9032abbbbt2LHjsEMPPXTQ2LFj5+6///7LAe6+++7ZgwYN+nT33XffulOnTsMGDx687V/+8pfukgA46aSTPqqoqGjVvXv3oWVlZUMLNYqgImrMu94aMWJETJgwodQxzMzMzKyEJE2MiBH5Lj958uRZQ4YMWVTMTOubK6+8sud1113XZ9asWVNLnSXb5MmTew4ZMmRgdfPcgmVmZmZmZk3C008/3fnNN99sX1VVxauvvtrh97//fZ9DDz10calz1YcHuTAzMzMzsyZh1qxZ7UaPHr3ZkiVL2nTv3r3ygAMO+OTSSy+t9ppaTZULLDMzMzMzaxKOP/74xccff3yzarHK5QJrPXHxvQ0/ae+Xoxrnx6ShGZ0v0dTzQdPP6HzrZtnVP23wul3OuKZgOWrT0IzOl2jq+czMmgKfg2VmZmZmVhhVVVVVKnUIK670Pa6qaX6LL7AktZZ0paSPJJVLelBSz1LnMjMzM7OWRdL8lStXNvg6UNY8rFy5cgNJ82ua3+ILLOBs4GDga8Cm6bQ7SxfHzMzMzFqiysrKC2fNmtVuxYoVHdyS1fJUVVVpxYoVHWbNmtWusrLywpqWWx/OwToOuCgi/gsg6efADEkDImJ2aaOZmZmZWUuxww47PP3aa6+dPHPmzPMjog/rR2PG+qRK0vzKysoLd9hhh6drWqhFF1iSugH9gYmZaRExU9IyYAgwO2vZ40iKMfr379+4Qc3MzMysRUg/eNf44dtavpZeVZel90tzpi8BumRPiIgbI2JERIzo1atXY2QzMzMzM7MWpqUXWOXpfdec6d2AZY0bxczMzMzMWroWXWBFxBLgfWCHzDRJm5O0Xk0pUSwzMzMzM2uhWnSBlboROEvSZpK6AFcAT0fErNLGMjMzMzOzlkYRUeoMRSWpNUlRNRpoDzwLHBcRi2paZ8SIETFhwoTGCWhmZmZmTZKkiRExotQ5rHlp0aMIAkTEWuDM9GZmZmZmZlY060MXQTMzMzMzs0bhAsvMzMzMzKxAXGCZmZmZmZkViAssMzMzMzOzAnGBZWZmZmZmViAusMzMzMzMzArEBZaZmZmZmVmBuMAyMzMzMzMrEBdYZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIG3yWUiSgCOAEUBZ9ryIOK4IuczMzMzMzJqdfFuw/gj8AegHtM25mZmZmZmZGXm2YAGHAztFxMxihjEzMzMzM2vO8m3BqgDeL2YQMzMzMzOz5i7fAus3wK/Sc7HMzMzMzMysGvl2ETwVGACcImlh9oyI2KrgqczMzMzMzJqhfAusS4qawszMzMzMrAXIq8CKiNuLHcTMzMzMzKy5y7cFC0k7AkeRDNX+AXBLRPynWMHMzMzMzMyam7wGuZB0CPAPoCswCegC/F3SocWLZmZmZmZm1rzk24J1PnBYRDyZmSBpX+By4OFiBDMzMzMzM2tu8h2mfSDwVM60p0lGFjQzMzMzMzPyL7BmA3vlTNsTX3zYzMzMzMzsM/l2EbwYeETSA8B7JC1ahwE/LlIuMzMzMzOzZievFqyIeJCkxaoCGAGsBL4dEQ8UMZuZmZmZmVmzkvcw7RHxCvBKEbOYmZmZmZk1azUWWJK+FhGvpo93qWm5tPAyMzMzMzNb79XWgvUcUJY+frmGZQJoXdBEZmZmZmZmzVSNBVZElGU9zne0QTMzMzMzs/VWXoWTpB/WMP3IwsYxMzMzMzNrvvJtmbquhunXFiqImZmZmZlZc5dvgaUvTZAGApUFTWNmZmZmZtaM1TpMu6Q1pANZSFqdM7s18MdiBTMzMzMzM2tu6roO1l4krVdPAvtmTa8C5kfEu8UKZmZmZmZm1tzUWmBFxN8BJG0REfMaJ5KZmZmZmVnzVFcLFgARMU9SD2BHoBdZ52RFxB1FymZmZmZmZtas5FVgSdoLeBBYDXQDlqT37wEusMzMzMzMzMh/FMHLgYsiohewPL2/GLihaMnMzMzMzMyamXwLrEHANenjTPfAK4CfFjiPmZmZmZlZs5VvgVUBtE8ffyypP9AO6F6UVGZmZmZmZs1QvgXWK8Ah6eO/AY8CzwH/KkImMzMzMzOzZimvQS6AH/B5MXYm8DOgDLi6GKHMzMzMzMyaozoLLEltgKtIiioi4lPg0iLnMrMW6OJ7Kxu03i9H5ftd0LpxvnXT0HzQ9DM2Vr5lV/+0Qet1OeOaguaoSUvNB00/o/Mlmno+M8iji2BEVAJHAKuKH8fMzMzMzKz5yvccrEeBw4oZpBgkHSHpJUnLJDX8q1UzMzMzM7M85NvnoS1wl6QTgFlAVWZGRBxXhFyF8glwPdABuLHEWczMzMzMrIXLt8BaA9ybPm6d3pq8iHgaQNLupU1iZmZmZmbrg7wKrIgYU+wgpSbpOOA4gP79+5c4jZmZmZmZNUf5noOFpK6Svi/p5+nzPpI2Ll60xhURN0bEiIgY0atXr1LHMTMzMzOzZiivAkvScGAGcDbwy3Ty9sC1RcplZmZmZmbW7OTbgnUN8POI2B7IjMb3CvD1YoQyMzMzMzNrjvId5GJb4Lb0cQBExHJJnYoRqlAktSYZAbFd+nyDdNaqiIiSBTMzMzMzsxZJ+dQZkqYDe0fEbEmLI2JDSVsCj0TEtkVP2UCSRgO3VjNrs4iYVdN6I0aMiAkTJhQrlpmZmZk1A5ImRsSIUuew5iXfLoK3A/8n6RuA0nOybgZuKlqyAoiI2yJC1dxmlTqbmZmZmZm1PPl2EbwC6AQ8CXQGXgR+hwe5MDMzMzMz+0y+18FaC5wLnCupZ0QsKm4sMzMzMzOz5iffYdqfyjzOLq4kPVGMUGZmZmZmZs1Rvudg7VLDdA/TbmZmZmZmlqq1i6Ck72eWkzQKUNbsQcAnxQpmZmZmZmbW3NR1Dtal6X174NdZ06uA+cApxQhlZmZmZmbWHNVaYEXEZgCSHo2IgxonkpmZmZmZWfOU1zlYLq7MzMzMzMzqVmMLlqTfR8Sp6eMba1ouIo4rRjAzMzMzM7PmprYugm1reGxmZmZmZmbVqLHAiogTsx6PaZw4ZmZmZmZmzVe+18EyMzMzMzOzOrjAMjMzMzMzKxAXWGZmZmZmZgXiAsvMzMzMzKxAai2wJD0qaT9JaqxAZmZmZmZmzVVdLVgfA/cDsyT9UtLGjZDJzMzMzMysWaq1wEqHZ98Y+A3wXZJC6xFJ+7pVy8zMzMzM7IvqPAcrIpZFxHURMQzYDVhE0qr1nqTzih3QzMzMzMysuajXIBcR8WpEHE1SaK0FLixKKjMzMzMzs2Yo7wJLUhtJh0t6FpgAzAF+WLRkZmZmZmZmzUybuhaQtBVwLPCjdPnbgVMi4u0iZzMzMzMzM2tWai2wJP0d+AbwT+BnwF8iYlVjBDMzMzMzM2tu6mrBmgScEBFvNUYYMzMzMzOz5qyuc7AuB7arboak70nqXfhIZmZmZmZmzVNdBdbPgUE1zNscOKuwcczMzMzMzJqvugqs/YCba5h3K3BAYeOYmZmZmZk1X3UVWH0iYkF1M9LpfQofyczMzMzMrHmqq8BaLalvdTPS6WsKH8nMzMzMzKx5qqvA+idwSg3zfgK8VNg4ZmZmZmZmzVddw7RfCrwkqRdwL/AhsAkwCjiS5BpZZmZmZmZmRh0FVkRMkHQQcB1wNBCAgBnAQRHxWvEjmpmZmZmZNQ91tWAREc8CW0kaBPQCPoqId4uezMzMzMzMrJmps8DKSIsqF1ZmZmZmZmY1qGuQCzMzMzMzM8uTCywzMzMzM7MCcYFlZmZmZmZWIC6wzMzMzMzMCsQFlpmZmZmZWYG4wDIzMzMzMysQF1hmZmZmZmYF4gLLzMzMzMysQFxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgbUodoKUYePYTDVpv1uX7FzhJ9ba7fbsGr/vGj98oYJKaNTSj8yWaej6A6054oUHr/eSGPQqcpHrOt27mnP1Sg9fd9PLdCpikZg3N2Fj5nn9hiwatt+ceMwucpHpNPd+t785t8LpjBm1cwCQ1a2hG50s09Xxm4BYsMzMzMzOzgnGBZWZmZmZmViBNssCS1LbUGczMzMzMzOqr0QosSX0kPSZpqaR3JB0tKSQNlHSbpLvT+8XA79N1TpQ0PV1nvKTdsrZ3gaTncvYxTtJ56ePdJVVK+rGk2ZIWp9vv3Fiv2czMzMzM1i+N2YJ1N7Aa6Ad8A/hhzvzDgb8BvYCfSRoFXAz8COgB3AQ8JWlAPfbZGjgQ2B74KrAVcHV1C0o6TtIESRM++uijeuzCzMzMzMws0SgFlqRNgT2AsRGxLCIWkhRP2V6OiPsiYm1EVABjgD9FxKsRURkRfwamAN+v5+7PioilEbEA+BXwI0lfet0RcWNEjIiIEb169ar3azQzMzMzM2usFqxN0vv3s6bNzllmVs7zfsB7OdNmptPrI3s/s4D2QM96bsPMzMzMzKxOjVVgfZje98+a1j9nmaqc5x8AA3OmbZ5OBygHOuXMr+4iB9ldCgcCq4BFNUc1MzMzMzNrmEYpsCJiDjAOuFxSmaRewHl1rHYbcLyknSS1kTQGGArck86fCOwgaXg6/2Rgs2q2c5mkLpJ6AxcAd0ZEbjFnZmZmZma2zhQRjbMjqS/JQBW7AQuA3wLXk7Q6XQZURsQxOeucDJwKbARMB34eEeOy5l8GZNa5Id32cxFxiaTdgeeAo4GLgC7AY8BPIqK8tqwjRoyICRMmrMOrNTMzM7PmTtLEiBhR6hzWvDRagfWlHUvfAR4BOkQRQmQKrIhoU991XWCZmZmZmQssa4h6Fx8NJWkoyXlWb5B05bsEuK8YxZWZmZmZmVkpNOZ1sLoDDwHLgZdJhlw/rRH3b2ZmZmZmVlSN1oIVES8CWzbi/sbRiK/PzMzMzMysMVuwzMzMzMzMWjQXWGZmZmZmZgXiAsvMzMzMzKxAXGCZmZmZmZkViAssMzMzMzOzAnGBZWZmZmZmViAusMzMzMzMzArEBZaZmZmZmVmBuMAyMzMzMzMrEBdYZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIC6wzMzMzMzMCsQFlpmZmZmZWYG4wDIzMzMzMysQF1hmZmZmZmYF4gLLzMzMzMysQFxgmZmZmZmZFYgLLDMzMzMzswJxgWVmZmZmZlYgLrDMzMzMzMwKxAWWmZmZmZlZgbjAMjMzMzMzKxAXWGZmZmZmZgXiAsvMzMzMzKxAXGCZmZmZmZkViAssMzMzMzOzAnGBZWZmZmZmViCKiFJnaHIkfQTMLuAmewKLCri9Qmvq+aDpZ3S+ddfUMzrfumnq+aDpZ3S+ddfUMzrfuilGvgER0avA27QWzgVWI5A0ISJGlDpHTZp6Pmj6GZ1v3TX1jM63bpp6Pmj6GZ1v3TX1jM63bpp6Plt/uIugmZmZmZlZgbjAMjMzMzMzKxAXWI3jxlIHqENTzwdNP6PzrbumntH51k1TzwdNP6PzrbumntH51k1Tz2frCZ+DZWZmZmZmViBuwTIzMzMzMysQF1hmZmZmZmYF4gLLzMzMzMysQFxgFZGk1pKulPSRpHJJD0rqWepcGZKOkPSSpGWSKkudJ5ekKyS9meabK+kmSRuWOlc2SZdKei/NuFDSA5L6lzpXLkmtJL0iKSRtWuo8AJJuk7RG0vKs20mlzlUdSXtJGp9mXCTp+lJnAkh/P7KP38r0Pd6h1NkyJPWRdF/6d/ATSS9IGlLqXBmSeki6XdJ8SUsl3SOpewnz1Pp3WdI+6fu+UtJUSXs3lXySNpH0iKTZ6c/hDxozW54Z90t/BhelP48vSdqtCeXbTdJrkhanP4+vSfpuU8mXs9yJ6ft8XmPmS/dd2zHcPc2V/bfxlcbOaOs3F1jFdTZwMPA1IPOh9s7SxfmST4DrgZ+WOEdN1gI/AHoAQ0iO4W2lDFSNO4GhEdEFGAi8D/xfSRNV73SgotQhqnF7RHTOujWJwiWbpN2BB4CrSH4WNwVuLmGkz0TEttnHD7gamBYRr5U6W5brgQ2BrYCNgAnA45JU0lSfuwPoDAwCNiN5j0v5d7rGv8uSNgceAi4Duqb3D0sa2BTyAVXAM8D3gTmNmClXbRm7A9cCWwK9gHuAv0nq12jpas83HTiU5OewW7rMXZK+2kjZII/PBpIGAD8D3mikTLnqyrg253/LLo0XzQzalDpAC3cccFFE/BdA0s+BGZIGRMTs0kaDiHgaPvsA2eRExDlZTz+S9Dvg/lLlqU5EvJ31VCQfMLYuUZxqSdoKOAk4DJhU4jjN0WXADRHxQNa0plTAACCpDXAUSd6mZEvgDxHxCYCkPwNjST5ALiplMEmdgH2BYRFRnk77NTBOUv+IeL+xM9Xxd/nHwMSIuCt9frekE9LpF5Y6X0TMA65L569tjDzVqSPj3TmT/ijpfGBH4IOih6POfAszjyW1Ivmf0ork9+itUufL8mfgXODERoj0JU3984uZW7CKRFI3oD8wMTMtImYCy0haY6z+9gQmlzpELknfl7QUWA6cBlxQ2kSfS/9B3wKcCSwpbZpqHZZ2hXlHSXfazqUOlC39AL4T0CbtqrNI0jhJI0qdrRqHkLRq3FHiHLmuJHmfe0nagOSLp5cjoqTFVUpZt4zM/8WhjZ6mbkPI+p+Seg3/T2kwSdsBPSldS0y1JC0BVgEvAa+StAw2CZKOB1ZExH2lzlKL1pI+SLv+PtGUuiXb+sEFVvGUpfdLc6YvAbo0bpTmT9JhwAkkBUyTEhH3RERXoC9JcdWU/lGfBsyPiIdLHaQa1wJfIflwcyjwTeCmkib6su4kfydHAaOBjUk+6DyZfonSlBwP3BcRS0odJMc/gdbAQpIvIb4LHFvSRKmIWA6MAy6Q1E1SLyDTct4U/06X4f8pBSOpN/AgcFVEvFvqPNkiohtJ19VDgSeBJnGetJJzjM8j6RXRVL1N8gXJZiT/Y6YAL0jauJShbP3iAqt4ytP7rjnTu5G0YlmeJB1O8sH7oCZ2bskXRMR8kpyPqwkMxiFpS5I+8ieXOkt1ImJiRCyIiKqIeJPkPLH/ldS+1NmyZH6Pb42IKRGxmqQLXlugyfTpl7QFSQvvDaXOki1tQX0OeIfkb2FH4FLgJUkblTJblh+QtBS8BfwbeCSd3hRa2HKV4/8pBZF+2H6R5AuTX5Q4TrUiYlVE/JXky6djShwn42bgkoj4sNRBahIR8yNickRURsSSiPgFsJikO7BZo3CBVSTpt8jvA5+N5pWeoNyF5NsUy4OkMcCfgAMj4sVS58lDG6ATSUtHqX2D5CTuqZIW8fl5Q1PUNEfrq0rvm8rgB0TEUmAWELmzqplWSscDkyPi1VIHybEhybfI10bEsohYHRE3k/zv2bm00RIR8WFEjIyIvhGxGfAe8CkwvsTRqjOZrP8pqWE0wa7TTVk6KMhLwN8i4uSIaEq/y9VpQzIIS1PwbeDXaXfpRcCuwC8kvVTiXHWpogn9b7GWzwVWcd0InCVpM0ldgCuApyNiVmljJZQMI78B0C59vkF6axJ/hCSdSjJy23ci4p+lzpNLydDnJ6fdTFAy/Pl1JB/I365t3UZyP7AFSVeJocB+6fS9aQLn6aTD7HZLHw8C/h/waER8WtJgX3Y9MEbSNulAEmNJWjyaxLC/ktqRdF9sUq1XAOl5Vu8AJ0nqJKmNpKNIuro1iS+aJG0tacP093lH4Brg8lJ1tazj7/IdwAhJoyS1lTQKGA7c3kTyffac5MNs2/R5ow6oVVtGSV8BXgbujYgzGzNXnvkOk7Rd+ruygaRjgT2Ap5tCPqAfyTl/Q9PbBJL/e//bWPnqyihpD0lbpr/TnSVdQDKCaaMdQzMiwrci3UjOO7iKpKtJOcnwuj1LnSsr32g+/yY++zaw1NnSfAGsITlv47NbqXNl5WtF0jd+IbAC+BC4G9ii1NlqyDswPaabljpLmmccSbeNFSStBlcDXUqdq5qcAi4C5pOc7/IiydD8Jc+W5juCpItY51JnqSHfV4HH07+DS0kGaTi41Lmy8h0LzCO5jMG7wGklzlPr32VgH+BNYGV6v3cTy1fdvAuaSkbg1vTx8pzbkU0k38npz+Hy9O/jv4DDm8rxq2bZccB5jZkvj2N4OjA7/d+yEHgK2LGxM/q2ft8U0dRbxs3MzMzMzJoHdxE0MzMzMzMrEBdYZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIC6wzMzWY5IukPTcOqx/jqTH1jHDDEmj12UbZmZmTYULLDOzRiJpc0l/kTRf0nJJH0h6WFK7UmdrqIj4dUQcWOocZmZmTYULLDOzxvMkMA/YGigDdgaeBlTKUGZmZlY4LrDMzBqBpB4khdUNEbE0EnMi4oaIWJUuM0TS3yUtkvSJpL9J2iJrG7dJulPSLZKWSPpQ0ihJQyX9R1K5pBclbZy1zixJv5L0ctpqNkHSjrXk7CjpKknvSVos6SlJW9ay/Be6GKb7O0fS8+n+pkraJWt+W0lXS1qYtuSdVc02d0vzLpY0U9LPJCmdd6ekZyS1Sp/vLmmZpO3yfS/MzMyKyQWWmVkjiIiPgTeBmyX9SNI2maIhezHgAmATYCCwHLgrZ5n/BR4ENgQuBm4CLgIOBTZKt3FhzjonAKel6zwAPCmpSw1RbwK+Anwd6AO8CjwuqW09Xu5RwKlAV+BZ4PaseWcDBwC7AJulr3NAZqakbUha+q4EegH7AycDP8x6LZsC50naCLgXOC0i3qhHPjMzs6JxgWVm1nh2B8YBPwVeBxZI+mWm0IqIKRHxYkSsioilJIXS1yV1zNrGCxHxRERUAXcAnYA709awCpICakTOfv8cERMjYjVwBbCSpMj5Akk9ge8DJ0XEgnT5C4G+wNfq8Tr/FBFvRsRa4GZgS0ld03k/Aq6IiBkRsRI4k6QozDgJ+EtEPBIRayPibeAP6XpExArg8HS9Z4GnIuLWemQzMzMrqjalDmBmtr6IiEXAOcA5adH0PZIWow+BW9LugFeSFDNlfF549AJmp4/nZW2vIq3NPpsGVKTrZpuVtU5Iep+kFSjXZun9lJzGtbZAv7xeZE5GYEV6XwYsTfebnWeFpIU5GfaQ9N2saa2AD7LWeVPSi8CBwCH1yGVmZlZ0bsEyMyuBiKiIiNuAKcDQdPINQDmwfUR0AXZNp6/rIBgDMw/S1rL+wJxqlssUcYMiolvWrWNE3LuOGTI+zMnTiaSAzM5wS87+u0TEtlnr/ICkC+MDJF0u/b/MzMyaDP9TMjNrBJK6S7pM0uB0oIc2kg4DBgMvpYt1IWnxWZJ217uoQLs/StIO6XlUY4GOwBO5C0XEQuAe4HpJm6S5u0k6VFLnAmW5ExgraQtJHYDf8MX/RdcDR0g6MOs4bSPpm2merwLXAUcCPwZ6kpy3ZmZm1iS4wDIzaxyrgd7AQ8Bi4CPgPODUiPhLuszpwG7AMpKi6/EC7ftG4PfAJ8BIYP/0HK/qHAtMB8ZJKgfeIDnnKWpYvr4uIxmafjzwHvA+n7ecERFTSc4P+ylJV8OFwG1Ar7Rb5V+A30bEc+k5XN8DTpP07QLlMzMzWyeKKNT/TDMza2okzQLOi4jc0QjNzMysCNyCZWZmZmZmViAusMzMzMzMzArEXQTNzMzMzMwKxC1YZmZmZmZmBeICy8zMzMzMrEBcYJmZmZmZmRWICywzMzMzM7MCcYFlZmZmZmZWIP8f/zK+xPjueGcAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "cv_args = {\"test_size\": 2, \"train_size\": 2, \"n_splits\": 2}\n", - "\n", - "test_cv(X, y, groups, **cv_args)\n", - "plot_cv(X, y, groups, **cv_args)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Groups are not sorted**" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['2021-06',\n", - " '2021-06',\n", - " '2021-06',\n", - " '2021-06',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-04',\n", - " '2021-04',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-05',\n", - " '2021-05',\n", - " '2021-01']" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "not_sorted_months = [\n", - " \"2021-06\",\n", - " \"2021-06\",\n", - " \"2021-06\",\n", - " \"2021-06\",\n", - " \"2021-02\",\n", - " \"2021-02\",\n", - " \"2021-02\",\n", - " \"2021-02\",\n", - " \"2021-04\",\n", - " \"2021-04\",\n", - " \"2021-03\",\n", - " \"2021-03\",\n", - " \"2021-03\",\n", - " \"2021-05\",\n", - " \"2021-05\",\n", - " \"2021-01\",\n", - "]\n", - "not_sorted_months" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([5, 5, 5, 5, 1, 1, 1, 1, 3, 3, 2, 2, 2, 4, 4, 0])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "not_sorted_groups = np.fromiter(map(months_map.get, not_sorted_months), dtype=\"int\")\n", - "not_sorted_groups" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
num_feature
2021-060
2021-067
2021-066
2021-064
2021-024
2021-028
2021-020
2021-026
2021-042
2021-040
2021-035
2021-039
2021-037
2021-057
2021-057
2021-017
\n", - "
" - ], - "text/plain": [ - " num_feature\n", - "2021-06 0\n", - "2021-06 7\n", - "2021-06 6\n", - "2021-06 4\n", - "2021-02 4\n", - "2021-02 8\n", - "2021-02 0\n", - "2021-02 6\n", - "2021-04 2\n", - "2021-04 0\n", - "2021-03 5\n", - "2021-03 9\n", - "2021-03 7\n", - "2021-05 7\n", - "2021-05 7\n", - "2021-01 7" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X_not_sorted = X.copy()\n", - "X_not_sorted.index = not_sorted_months\n", - "X_not_sorted" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TRAIN INDICES: [0 1 2 3 4 5 6 7 8 9]\n", - "TEST INDICES: [10 11 12]\n", - "TRAIN LENGTH: 10\n", - "TEST LENGTH: 3\n", - "TRAIN GROUPS: [5 5 5 5 1 1 1 1 3 3]\n", - "TEST GROUPS: [2 2 2]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06' '2021-02' '2021-02' '2021-02'\n", - " '2021-02' '2021-04' '2021-04']\n", - "TEST GROUP MONTHS: ['2021-03' '2021-03' '2021-03']\n", + "- `test_size` : int\n", "\n", - "TRAIN INDICES: [ 4 5 6 7 8 9 10 11 12]\n", - "TEST INDICES: [13 14]\n", - "TRAIN LENGTH: 9\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: [1 1 1 1 3 3 2 2 2]\n", - "TEST GROUPS: [4 4]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-04' '2021-04' '2021-03'\n", - " '2021-03' '2021-03']\n", - "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", + " Size of test dataset.\n", "\n", - "TRAIN INDICES: [ 8 9 10 11 12 13 14]\n", - "TEST INDICES: [15]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 1\n", - "TRAIN GROUPS: [3 3 2 2 2 4 4]\n", - "TEST GROUPS: [0]\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-04' '2021-04' '2021-03' '2021-03' '2021-03' '2021-05' '2021-05']\n", - "TEST GROUP MONTHS: ['2021-01']\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", - "\n", - "test_cv(X_not_sorted, y, not_sorted_groups, **cv_args)\n", - "plot_cv(X_not_sorted, y, not_sorted_groups, **cv_args)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Group names**" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TRAIN INDICES: [0 1 2 3 4 5 6 7]\n", - "TEST INDICES: [8 9]\n", - "TRAIN LENGTH: 8\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", - " '2021-03']\n", - "TEST GROUPS: ['2021-04' '2021-04']\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", - " '2021-03']\n", - "TEST GROUP MONTHS: ['2021-04' '2021-04']\n", + "- `train_size` : int (default=None)\n", "\n", - "TRAIN INDICES: [1 2 3 4 5 6 7 8 9]\n", - "TEST INDICES: [10 11]\n", - "TRAIN LENGTH: 9\n", - "TEST LENGTH: 2\n", - "TRAIN GROUPS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", - " '2021-04' '2021-04']\n", - "TEST GROUPS: ['2021-05' '2021-05']\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", - " '2021-04' '2021-04']\n", - "TEST GROUP MONTHS: ['2021-05' '2021-05']\n", + " Size of train dataset.\n", + "\n", + "- `n_splits` : int (default=None)\n", + "\n", + " Number of the splits.\n", + "\n", + "- `gap_size` : int (default=0)\n", + "\n", + " Gap size between train and test datasets.\n", + "\n", + "- `shift_size` : int (default=1)\n", + "\n", + " Step to shift for the next fold.\n", + "\n", + "- `window_type` : str (default=\"rolling\")\n", + "\n", + " Type of the window. Possible values: \"rolling\", \"expanding\".\n", + "\n", + "**Examples**\n", + "\n", + "For usage examples, please see\n", + " http://rasbt.github.io/mlxtend/user_guide/evaluate/GroupTimeSeriesSplit/\n", + "\n", + "### Methods\n", + "\n", + "
\n", + "\n", + "*get_n_splits(X=None, y=None, groups=None)*\n", + "\n", + "Returns the number of splitting iterations in the cross-validator.\n", + "\n", + "**Parameters**\n", + "\n", + "- `X` : object\n", + "\n", + " Always ignored, exists for compatibility.\n", + "\n", + "- `y` : object\n", + "\n", + " Always ignored, exists for compatibility.\n", + "\n", + "- `groups` : object\n", + "\n", + " Always ignored, exists for compatibility.\n", + "\n", + "**Returns**\n", + "\n", + "- `n_splits` : int\n", + "\n", + " Returns the number of splitting iterations in the cross-validator.\n", + "\n", + "
\n", + "\n", + "*split(X, y=None, groups=None)*\n", + "\n", + "Generate indices to split data into training and test set.\n", + "\n", + "**Parameters**\n", + "\n", + "- `X` : array-like\n", + "\n", + " Training data.\n", + "\n", + "- `y` : array-like (default=None)\n", + "\n", + " Always ignored, exists for compatibility.\n", + "\n", + "- `groups` : array-like (default=None)\n", + "\n", + " Array with group names or sequence numbers.\n", + "\n", + "**Yields**\n", + "\n", + "- `train` : ndarray\n", + "\n", + " The training set indices for that split.\n", + "\n", + "- `test` : ndarray\n", + "\n", + " The testing set indices for that split.\n", "\n", - "TRAIN INDICES: [ 5 6 7 8 9 10 11]\n", - "TEST INDICES: [12 13 14 15]\n", - "TRAIN LENGTH: 7\n", - "TEST LENGTH: 4\n", - "TRAIN GROUPS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", - "TEST GROUPS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", - "TRAIN GROUP SIZE: 3\n", - "TEST GROUP SIZE: 1\n", - "TRAIN GROUP MONTHS: ['2021-03' '2021-03' '2021-03' '2021-04' '2021-04' '2021-05' '2021-05']\n", - "TEST GROUP MONTHS: ['2021-06' '2021-06' '2021-06' '2021-06']\n", "\n" ] } ], "source": [ - "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", - "\n", - "test_cv(X, y, months, **cv_args)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Usage in CV" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.5 , 0.25])" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cv_args = {\"test_size\": 1, \"train_size\": 3}\n", - "cv = GroupTimeSeriesSplit(**cv_args)\n", - "clf = DummyClassifier(strategy=\"most_frequent\")\n", - "\n", - "scores = cross_val_score(clf, X, y, groups=groups, scoring=\"accuracy\", cv=cv)\n", - "scores" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1 0 1 0 1 0 0 1] [0 0 0 0 0 0 0 0] [1 1] [0 0]\n", - "[0 1 0 1 0 0 1 1 1] [1 1 1 1 1 1 1 1 1] [0 1] [1 1]\n", - "[0 0 1 1 1 0 1] [1 1 1 1 1 1 1] [1 0 0 0] [1 1 1 1]\n" - ] - } - ], - "source": [ - "clf = DummyClassifier(strategy=\"most_frequent\")\n", - "\n", - "for train_idx, test_idx in cv.split(X, y, groups):\n", - " clf.fit(X.iloc[train_idx], y.iloc[train_idx])\n", - " y_train_pred = clf.predict(X.iloc[train_idx])\n", - " y_test_pred = clf.predict(X.iloc[test_idx])\n", - " print(y.iloc[train_idx].values, y_train_pred, y.iloc[test_idx].values, y_test_pred)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Failed cases" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- Groups are not consecutive\n", - "- Both train_size and n_splits are specified\n", - "- Incorrect window name\n", - "- Specify train_size with expanding window\n", - "- Not enough data (too many number of splits)\n", - "- Not enough data (too large value of shift size)\n", - "- Not enough data (too large value of gap size)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Groups are not consecutive**" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['2021-01',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-02',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-04',\n", - " '2021-04',\n", - " '2021-05',\n", - " '2021-05',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-03',\n", - " '2021-03']" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "not_consecutive_months = [\n", - " \"2021-01\",\n", - " \"2021-02\",\n", - " \"2021-02\",\n", - " \"2021-02\",\n", - " \"2021-02\",\n", - " \"2021-03\",\n", - " \"2021-03\",\n", - " \"2021-03\",\n", - " \"2021-04\",\n", - " \"2021-04\",\n", - " \"2021-05\",\n", - " \"2021-05\",\n", - " \"2021-03\",\n", - " \"2021-03\",\n", - " \"2021-03\",\n", - " \"2021-03\",\n", - "]\n", - "not_consecutive_months" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 2, 2, 2, 2])" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "not_consecutive_groups = np.fromiter(\n", - " map(months_map.get, not_consecutive_months), dtype=\"int\"\n", - ")\n", - "not_consecutive_groups" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The groups should be consecutive\n" - ] - } - ], - "source": [ - "try:\n", - " test_cv(X, y, not_consecutive_groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Both train_size and n_splits are not specified**" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Either train_size or n_splits should be defined\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 3}\n", - "\n", - "try:\n", - " test_cv(X, y, groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Incorrect window name**" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Window type can be either \"rolling\" or \"expanding\"\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 3, \"n_splits\": 3, \"window_type\": \"bad_name\"}\n", - "\n", - "try:\n", - " test_cv(X, y, groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Specify train_size with expanding window**" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train size can be specified only with rolling window\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 3, \"train_size\": 3, \"window_type\": \"expanding\"}\n", - "\n", - "try:\n", - " test_cv(X, y, groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Not enough data (too large train_size and/or n_splits)**" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Not enough data to split number of groups (6) for number splits (10) with train size (10), test size (1), gap size (0), shift size (1)\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 1, \"train_size\": 10, \"n_splits\": 10}\n", - "\n", - "try:\n", - " test_cv(X, y, groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Not enough data (too many number of splits)**" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Not enough data to split number of groups (6) for number splits (10) with train size (-4), test size (1), gap size (0), shift size (1)\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 1, \"n_splits\": 10}\n", - "\n", - "try:\n", - " test_cv(X, y, groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Not enough data (too large values of shift size)**" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Not enough data to split number of groups (6) for number splits (3) with train size (-15), test size (1), gap size (0), shift size (10)\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 1, \"n_splits\": 3, \"shift_size\": 10}\n", - "\n", - "try:\n", - " test_cv(X, y, groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Not enough data (too large values of gap size)**" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Not enough data to split number of groups (6) for number splits (3) with train size (-7), test size (1), gap size (10), shift size (1)\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 1, \"n_splits\": 3, \"gap_size\": 10}\n", - "\n", - "try:\n", - " test_cv(X, y, groups, **cv_args)\n", - "except ValueError as e:\n", - " print(e)" + "with open(\"../../api_modules/mlxtend.evaluate/GroupTimeSeriesSplit.md\", \"r\") as f:\n", + " s = f.read()\n", + "print(s)" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "mlxtend", "language": "python", - "name": "python3" + "name": "mlxtend" }, "language_info": { "codemirror_mode": { @@ -1737,7 +762,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/mlxtend/evaluate/time_series.py b/mlxtend/evaluate/time_series.py index efa7bde35..242c83b3c 100644 --- a/mlxtend/evaluate/time_series.py +++ b/mlxtend/evaluate/time_series.py @@ -7,7 +7,10 @@ from itertools import accumulate, chain, groupby, islice +import matplotlib.pyplot as plt import numpy as np +from matplotlib.patches import Patch +from matplotlib.ticker import MaxNLocator from sklearn.utils import indexable @@ -230,3 +233,117 @@ def _calculate_split_params(self): ) self._train_start_idx = train_start_idx + + +def print_split_info(X, y, groups, **cv_args): + """Print information details about splits.""" + cv = GroupTimeSeriesSplit(**cv_args) + groups = np.array(groups) + + for train_idx, test_idx in cv.split(X, groups=groups): + print("Train indices:", train_idx) + print("Test indices:", test_idx) + print("Train length:", len(train_idx)) + print("Test length:", len(test_idx)) + print("Train groups:", groups[train_idx]) + print("Test groups:", groups[test_idx]) + print("Train group size:", len(set(groups[train_idx]))) + print("Test group size:", len(set(groups[test_idx]))) + print("Train group months:", X.index[train_idx].values) + print("Test group months:", X.index[test_idx].values) + print() + + +def plot_split_indices(cv, cv_args, X, y, groups, n_splits, image_file_path=None): + """Create a sample plot for indices of a cross-validation object.""" + fig, ax = plt.subplots(figsize=(12, 4)) + cmap_data = plt.cm.tab20 + cmap_cv = plt.cm.coolwarm + lw = 10 + marker_size = 200 + + for split_idx, (train_idx, test_idx) in enumerate( + cv.split(X=X, y=y, groups=groups) + ): + indices = np.array([np.nan] * len(X)) + indices[test_idx] = 1 + indices[train_idx] = 0 + + ax.scatter( + range(len(X)), + [split_idx + 0.5] * len(X), + c=indices, + marker="_", + lw=lw, + cmap=cmap_cv, + vmin=-0.4, + vmax=1.4, + s=marker_size, + ) + + ax.scatter( + range(len(X)), + [split_idx + 1.5] * len(X), + c=groups, + marker="_", + lw=lw, + cmap=cmap_data, + s=marker_size, + ) + + yticklabels = list(range(n_splits)) + ["group"] + ax.set( + yticks=np.arange(n_splits + 1) + 0.5, + yticklabels=yticklabels, + ylabel="CV iteration", + ylim=[n_splits + 1.2, -0.2], + xlim=[-0.5, len(indices) - 0.5], + ) + + ax.legend( + [Patch(color=cmap_cv(0.2)), Patch(color=cmap_cv(0.8))], + ["Training set", "Testing set"], + loc=(1.02, 0.8), + fontsize=13, + ) + + ax.set_title("{}\n{}".format(type(cv).__name__, cv_args), fontsize=15) + ax.xaxis.set_major_locator(MaxNLocator(min_n_ticks=len(X), integer=True)) + ax.set_xlabel(xlabel="Sample index", fontsize=13) + ax.set_ylabel(ylabel="CV iteration", fontsize=13) + ax.tick_params(axis="both", which="major", labelsize=13) + ax.tick_params(axis="both", which="minor", labelsize=13) + + plt.tight_layout() + + if image_file_path: + plt.savefig(image_file_path, bbox_inches="tight") + + plt.show() + + +def plot_splits(X, y, groups, image_file_path=None, **cv_args): + """Visualize splits by group.""" + cv = GroupTimeSeriesSplit(**cv_args) + cv._n_groups = len(np.unique(groups)) + cv._calculate_split_params() + n_splits = cv.n_splits + + plot_split_indices( + cv, cv_args, X, y, groups, n_splits, image_file_path=image_file_path + ) + + +def print_cv_info(cv, X, y, groups, clf, scores): + """Print information details about cross-validation usage with classifier.""" + for split_idx, (train_idx, test_idx) in enumerate(cv.split(X, y, groups)): + clf.fit(X.iloc[train_idx], y.iloc[train_idx]) + y_train_pred = clf.predict(X.iloc[train_idx]) + y_test_pred = clf.predict(X.iloc[test_idx]) + print(f"Split number: {split_idx + 1}") + print(f"Train true target: {y.iloc[train_idx].values}") + print(f"Train predicted target: {y_train_pred}") + print(f"Test true target: {y.iloc[test_idx].values}") + print(f"Test predicted target: {y_test_pred}") + print(f"Accuracy: {scores[split_idx].round(2)}") + print() From 8a69587390348778426a80809a7283914bcdcfa0 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 21 May 2022 14:46:08 +0300 Subject: [PATCH 25/30] Reformat documentation --- .../evaluate/GroupTimeSeriesSplit.ipynb | 114 +++++++++++++++--- 1 file changed, 100 insertions(+), 14 deletions(-) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index 1761a1b07..0d29b1781 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -44,10 +44,15 @@ "- Shift size \n", "- Window type \n", "\n", + "This implementation has several advantages over scikit-learn's [TimeSeriesSplit](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html):\n", + "- Here you can group data as you want before splitting, while TimeSeriesSplit considers only record level.\n", + "- It can be used for both cases: holdout validation (n_splits=1) and cross-validation (n_splits>=2), whereas TimeSeriesSplit can be used only for the latter case.\n", + "- TimeSeriesSplit uses only expanding window, while for this implementation you can choose between rolling and expanding window types.\n", + "- You have additional control for splitting using additional parameter: shift size.\n", + "\n", "There are several features that need to be taken into account:\n", "\n", "- Implementation is compatible with sklearn-learn API\n", - "- It can be used both for holdout split and cross-validation\n", "- Numbers or custom non-numeric values can be used as groups\n", "- Groups should be consecutive\n", "- Test size with either train size or number of splits are required parameters for splitting\n", @@ -57,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -83,6 +88,40 @@ "## Prepare sample data" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the following examples, we are creating sample dataset consisting of 16 training data points with corresponding targets." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Features and targets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's assume that we have one numeric feature and target for the binary classification task." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "data = [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]]\n", + "target = [1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0]\n", + "\n", + "X = pd.DataFrame(data, columns=[\"num_feature\"])\n", + "y = pd.Series(target, name=\"target\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -90,6 +129,24 @@ "### Group numbers" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We create 6 different groups so that the first training example belongs to group 0, the next 4 to group 1, and so forth. \n", + "These groups do not have to be in ascending order (as in this dataset), but they must be consecutive.\n", + "\n", + "Example of correct groups order (not sorted but consecutive):\n", + "```python\n", + "np.array([5, 5, 5, 5, 1, 1, 1, 1, 3, 3, 2, 2, 2, 4, 4, 0])\n", + "```\n", + "\n", + "Example of incorrect groups order (not consecutive):\n", + "```python\n", + "np.array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 2, 2, 2, 2])\n", + "```" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -118,6 +175,13 @@ "### Group names (months)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will add months as the index according to the specified groups for a more illustrative example." + ] + }, { "cell_type": "code", "execution_count": 4, @@ -143,30 +207,30 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 5, "metadata": {}, + "outputs": [], "source": [ - "### Features and targets" + "X = X.set_index(months)" ] }, { - "cell_type": "code", - "execution_count": 5, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "data = [[0], [7], [6], [4], [4], [8], [0], [6], [2], [0], [5], [9], [7], [7], [7], [7]]\n", - "target = [1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0]\n", - "\n", - "X = pd.DataFrame(data, index=months, columns=[\"num_feature\"])\n", - "y = pd.Series(target, name=\"target\")" + "## Example 1 -- Multiple training groups (with train size specified)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Example 1 -- Multiple training groups (with train size specified)" + "Let's create splitting with training dataset with size of 3 groups and test sizes of 1 group. \n", + "Number of splits will be calculated automatically. \n", + "\n", + "The first 3 rows in the visualization describe how each split is distributed among groups. \n", + "The groups are visualized in the last row where each color represents different group." ] }, { @@ -290,6 +354,14 @@ "## Example 2 -- Multiple training groups (with number of splits specified)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will split the dataset with test size (2 goups) and number of splits (3 groups) specified. \n", + "Train size will be calculated automatically. " + ] + }, { "cell_type": "code", "execution_count": 8, @@ -406,7 +478,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Example 3 -- Defining the gap size between training and test folds" + "## Example 3 -- Defining the gap size between training and test datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make a splitting where we have a gap of the size of 1 group between training and test datasets." ] }, { @@ -528,6 +607,13 @@ "## Example 4 -- Expanding the window size" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we try to expand training dataset set to 4 groups (in comparison with example 1), then number of splits will be adjusted accordingly." + ] + }, { "cell_type": "code", "execution_count": 12, From 75af8f0a6d158e5dff7f2b89af79072cdfda778d Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Sat, 21 May 2022 20:56:01 +0300 Subject: [PATCH 26/30] Fix overview list formatting --- docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index 0d29b1781..413ecdd19 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -45,6 +45,7 @@ "- Window type \n", "\n", "This implementation has several advantages over scikit-learn's [TimeSeriesSplit](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html):\n", + "\n", "- Here you can group data as you want before splitting, while TimeSeriesSplit considers only record level.\n", "- It can be used for both cases: holdout validation (n_splits=1) and cross-validation (n_splits>=2), whereas TimeSeriesSplit can be used only for the latter case.\n", "- TimeSeriesSplit uses only expanding window, while for this implementation you can choose between rolling and expanding window types.\n", From 37e92b51dc4b6a40620268dfc9f943defd335388 Mon Sep 17 00:00:00 2001 From: rasbt Date: Tue, 24 May 2022 09:43:16 -0500 Subject: [PATCH 27/30] some doc updates --- .../evaluate/GroupTimeSeriesSplit.ipynb | 109 +++++++++++------- 1 file changed, 70 insertions(+), 39 deletions(-) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index 413ecdd19..da4dc3c98 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -32,8 +32,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Time series tasks in machine learning require special type of validation, because the time order of the objects is important if we want to get more fair evaluation of the ML model’s quality. \n", - "Also there can be different units for splitting the data for different tasks - hours, days, months etc. \n", + "Time series tasks in machine learning require special type of validation, because the time order of the objects is important for a fairer evaluation of an ML model’s quality. \n", + "Also there can be different time units for splitting the data for different tasks - hours, days, months etc. \n", "\n", "Here, we use time series validation with support of the groups which can be flexibly configured along with other parameters:\n", "\n", @@ -44,21 +44,28 @@ "- Shift size \n", "- Window type \n", "\n", - "This implementation has several advantages over scikit-learn's [TimeSeriesSplit](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html):\n", + "This `GroupTimeSeriesSplit` implementation is inspired by scikit-learn's [TimeSeriesSplit](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html) but it has several advantages:\n", "\n", - "- Here you can group data as you want before splitting, while TimeSeriesSplit considers only record level.\n", - "- It can be used for both cases: holdout validation (n_splits=1) and cross-validation (n_splits>=2), whereas TimeSeriesSplit can be used only for the latter case.\n", - "- TimeSeriesSplit uses only expanding window, while for this implementation you can choose between rolling and expanding window types.\n", - "- You have additional control for splitting using additional parameter: shift size.\n", + "- `GroupTimeSeriesSplit` lets you group data as you want before splitting, while `TimeSeriesSplit` only considers the record level.\n", + "- It can be used for both holdout validation (n_splits=1) and cross-validation (n_splits>=2), whereas `TimeSeriesSplit` can be used only for the latter case.\n", + "- `TimeSeriesSplit` uses only an expanding window, while for this implementation you can choose between both rolling and expanding window types.\n", + "- `GroupTimeSeriesSplit` offers additional control for splitting using an additional `shift size` parameter.\n", "\n", - "There are several features that need to be taken into account:\n", + "**There are several features that need to be taken into account:**\n", "\n", - "- Implementation is compatible with sklearn-learn API\n", + "- `GroupTimeSeriesSplit` is compatible with sklearn-learn API.\n", "- Numbers or custom non-numeric values can be used as groups\n", - "- Groups should be consecutive\n", - "- Test size with either train size or number of splits are required parameters for splitting\n", - "- If full data can’t be used with specific parameters, the most recent data is considered to split\n", - "- If split is impossible (e.g., the data is not enough to split) using specified parameters, an exception will be raised " + "- However, groups should be consecutive\n", + "- Specifying the test size with either a) the train size or b) the number of splits is required parameters for splitting\n", + "- If full data can’t be used with specific parameters, the most recent data is considered for splitting\n", + "- If splitting is impossible (e.g., there is not enough data to split) using specified parameters, an exception will be raised " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we illustrate the usage of `GroupTimeSeriesSplit` in the following examples below, let's set up a `DummyClassifier` that we will reuse in the following sections. Also, let's import the libraries we will be using in the following examples:" ] }, { @@ -135,17 +142,7 @@ "metadata": {}, "source": [ "We create 6 different groups so that the first training example belongs to group 0, the next 4 to group 1, and so forth. \n", - "These groups do not have to be in ascending order (as in this dataset), but they must be consecutive.\n", - "\n", - "Example of correct groups order (not sorted but consecutive):\n", - "```python\n", - "np.array([5, 5, 5, 5, 1, 1, 1, 1, 3, 3, 2, 2, 2, 4, 4, 0])\n", - "```\n", - "\n", - "Example of incorrect groups order (not consecutive):\n", - "```python\n", - "np.array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 2, 2, 2, 2])\n", - "```" + "These groups do not have to be in ascending order (as in this dataset), **but they must be consecutive.**" ] }, { @@ -169,6 +166,21 @@ "groups" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the following i another example of a **correct** group ordering (not sorted but consecutive):\n", + "```python\n", + "np.array([5, 5, 5, 5, 1, 1, 1, 1, 3, 3, 2, 2, 2, 4, 4, 0])\n", + "```\n", + "\n", + "However, the example below shows an **incorrect** group ordering (not consecutive), which is not compatible with `GroupTimeSeriesSplit`:\n", + "```python\n", + "np.array([0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 2, 2, 2, 2])\n", + "```" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -227,8 +239,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's create splitting with training dataset with size of 3 groups and test sizes of 1 group. \n", - "Number of splits will be calculated automatically. \n", + "Let's create a time series splitting with a training dataset that consists of 3 groups. And we will use 1 group for testing. In this case, the number of splits will be calculated automatically since both the training set and the test set sizes are specified.\n", "\n", "The first 3 rows in the visualization describe how each split is distributed among groups. \n", "The groups are visualized in the last row where each color represents different group." @@ -241,7 +252,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -307,6 +318,13 @@ "### Usage in CV" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The example below illustrates how we can use the time series splitter with scikit-learn, i.e., using `cross_val_score`:" + ] + }, { "cell_type": "code", "execution_count": 7, @@ -359,8 +377,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we will split the dataset with test size (2 goups) and number of splits (3 groups) specified. \n", - "Train size will be calculated automatically. " + "Now let's take a look at an example where we don't specify the number of training groups. Here, we will split the dataset with test size (2 goups) and a specified number of splits (3 groups), which is sufficient for calculating the training size automatically." ] }, { @@ -370,7 +387,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -434,6 +451,13 @@ "### Usage in CV" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, let's take a look at how this looks in a scikit-learn context using `cross_val_score`:" + ] + }, { "cell_type": "code", "execution_count": 9, @@ -486,17 +510,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's make a splitting where we have a gap of the size of 1 group between training and test datasets." + "`GroupTimeSeriesSplit` let's you specify a gap size greater than 1 in order to skip a specified number of groups between training and test folds (the default gap size is 0). In the example below, we use a gap of 1 group to illustrate this." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABAP0lEQVR4nO3dd5ycVd3+8c+VSsqmkEIKJKErBJJA8BGQ34NgA6kixggqiFQpgkQQUakKwoMIggoIiIDSREAUpAsiSEJICCVATEJJI5CyyYYkm/3+/jj3wDDM9tmd3c31fr3mtTt3Ofc1Mzu7891z7nMrIjAzMzMzM7Pm61TuAGZmZmZmZh2FCywzMzMzM7MScYFlZmZmZmZWIi6wzMzMzMzMSsQFlpmZmZmZWYm4wDIzMzMzMysRF1hm1uFJOkDSPyS9I2mNpLck3S7pC+XOliNplKRowC233fGtmK2XpHMlzZS0StJCSY9JOqKEx5gj6eJStZfX7r6S/iVpqaTlkl6Q9BtJvRvZzmHZ8947u597HfbJ2+b7knYv7SMwM7P2pku5A5iZtSRJvwBOBG4Afg28A4wEvgr8XdIWETGrjBFz5gM7593fDLgJ+A7wbJHtZrdeNO4AxgHnATOAwcD/A/YGfleiYxxIem1KRtJE4Gbgt6TsAWwPfBPoB6xoRvO51+HlvGXfB34FPNqMds3MrJ2TLzRsZh2VpP2BvwCHR8T1RdbvC0yJiHlF1vWIiFUtHrIWkkYDzwOfjohHy5hjS+AV4CsRcVvBOkUz/4i05PMs6V/A0oj4YpF1jcou6TDgOqAiIooWZpIWA7+KiLOaltjMzDoCDxE0s47su8AzxYorgIi4J1dcZcO9TpF0qaS3ScUNkgZK+n02vLBK0qOSxue3U2zInqSzsg/cufu5IWY7SXo8G2r3iqQDG/ugCo+XZbpd0uGSZktaIekPkrpL+oSk/2TLHpU0oqCtDST9XNIbklZLmiZp77xN+mVfFxR5/j5UoEgaIelPkt7Nnqv7JW2dtz43rO4QSTdIWgrck637yBBBSbtlQxGrsuf/akkVeev7SbpG0jxJ70l6XdLVBdk/krswe95r/8ss+1JJl0vqVmzfgseyTy4/MAD4Sd5wzt1r29/MzDouF1hm1iFJ6kIawvWPRuw2CRgKfJ00rBBSD9jngVOBCaTfm49I2qKJ0W4B7gK+RCribpM0polt5fskaejbCaShal8BLgeuBn4JHEoadnhVwX63A4cBPwX2BZ4B7pY0Nls/E1gJXCrpc5I2KHZwSRsCTwBbA8dkx+8FPCipR8HmFwOVwMHZcYu1tyvwIKlA+jKpWN6b1IuUcwnwKeBk0mt0BmkYYM6zwERJx0saVuw4eb4HbAwcQhpOeBRwfj375DsQWEYaMrlzdnu2zj3MzKxD8jlYZtZRDQC6A2/kL5QkoHPeonV5vRnzI2JC3rZfAHYFdo+Ix7JlDwNzSMXY0U3IdU1EXJy1dT/wIvAD0jlhzdEb2D8ilmVt7w4cCfxvRPwzWzYMuEJSz4iokrQn8EXyHh/wD0lbAT8EDo6I5ZKOJBVq9wNrJT0F/CF7LLnn7mRSQTU2It7Njvcv0nP1LeCKvKxPRcR36nk8FwBPFrwebwEPSRodETOATwBXRMQtefvdmPf9GcB2pELzckmzSQXzzyOisGerMnu8NaRz87oDP5T0s9zjqUtETJVUDbwZEU/Vt72ZmXVc7sEys46u8Dyb7wFr8275H/T/VrDtJ4BFecUHEbES+Cup56Qp7sxrq4bUm/WJJraVb3KuuMq8Bqwh9SrlLwPI9eZ8htRD9C9JXXI34CHg/WGQEfFH0sQg3wL+BGxF6gm7Oa/tzwAPAMvz2qkEpuS3lbm3rgciqSepB+jWglxPkF6zHbNNnwMmSTouKwo/JCLeyLb9DPB/wLukQnC6pI0LNr8rez1y/gz0AEbXldXMzKyQCywz66jeAVaThn3l+wOwU3YrtLDg/lBgUS3bbdjEXIXtLcqO01xLC+6vASoLioY12dfcML+BwBA+XHCuBc4CNslvLCLeiYjrIuIb2brrgK/mDW8cSBpCWdjWpwvb4qPPc6H+pF7GKwvaWg10zWvveFKP1I+BmZJelfShnsCIWBcRD0XEqRExnjSUcENSoZ2v2OsCpXltzMxsPeIhgmbWIUVEtaR/A58jfQDPLV9I9gE/jRb88G4F9+eTpiQvtBGpNyRnNVA4IUL/WqIN5sPTkQ/OjlMO7wJvAQc0ZqeIWKs0/f3hwMeAaVlbdwPnFtmlsrCJeg6xNNvmLD7aqwgwL8uxlHSu3ImStiede3aTpOkR8WIt2f8haVqWO1/h65y7X67XxszM2in3YJlZR3Yp8D+Svt7E/Z8GBkv6f7kF2fC1L/LhoXdvAh/P26YTsGctbR5YsN3+wH+amK+5HiL1YK2IiMmFtyxjRZFJKgC2zL4uzGtrW+CFIm3NbEyobBjmU8DWxXIVm1Y/IqaTzovrRFY8SfpIcZxN0rExH+1F2z97PXK+BKwiXferodbwQe+gmZmtp9yDZWYdVkTcJelS4HpJnyZNCb6YNAHG57LNar3YbETcL+lJ4BZJp5N6nk4lnZtzUd6mdwLfkTQV+C/wbaBPLc1+W9Ia0gf3bwNbABOb9gib7QHSxBUPSLoQeIGUeyywQUT8gDQr4N2SrgWeBKqy9T8knQOVKzQvIc1U+LCky0k9YxsB/ws8kZ3H1RjfJ01oUUOa6bASGEEqbn8YEa9IeoL03M8g9XgdSZrxMFew3i/pZdLr/gapmDye1Lv424LjVZBmdLyaVCj+iDSBRr0TXOR5GfiipPtIP1czI6Kw987MzDo4F1hm1qFFxMmS/gkcR5pCuwJ4G/g3sHdE/L2eJg4gTZBwKal34j/AHhHxWt42Z5OGlJ1H6sX4FalYKTZT3leBX2TbvgFMiIipTXlszRURIelLpNn2vksqYN4lFU6XZ5vNAq4hnbt0LKm4fB24FrgwIqqzthZL+iRpavNfkK5BNZ9UgE1vQrYnsp7Ds0nnzXUG5gL38UHv079JU8yPAtYBU4G9IuLNbP3PSc/3haTX523S1OmfiojCXsP/I01j/0dSL9jvsuelMSaRZku8F+hJOv/s0Ua2YWZm7ZwacSF7MzNrIkmHkSaGqIiIWnvNrPVJCuCEiPhVubOYmVn753OwzMzMzMzMSsQFlpmZmZmZWYl4iKCZmZmZmVmJuAfLzMzMzMysRFxgmZmZmZmZlYgLLLN2TtJYSU9JWinpuoJ1IWn37Ptuks6SNLYFMrRI25IelXR7idvcPZs1rrH7DZJ0maT/SFojaU4zMhzWnP1bUuFznr2ui/Pub5Ut69fIdpv0mCV9WdKTkt6R9J6kmZLOlNStCW2dJenRxu7XVki6XtLkErc5Kvs9MaqR+3WTdJGkxyWtqu09Jem72fvllWwmTTOzDs8Flln7dx4wHDgk+7423YCfkC4SW2ot1fZxwA9K3GZTDQcmAAtI14laX+SugZWzFem17tdKxx8APEy6KPNepOtv/ZB0YeP1zbmk6361BT1Jr0kV6QLUtfkT6XWbDVwpaYNWyGZmVla+0LBZ+7cV8NeI+Eu5g5RaRLxY7gx5pkfERgCSLga+XOY8rSK7aO+b9W7Ycsf/bcGiRyT1Ab4j6YRYj2ZqiohZ5c6QExFLJW2YXaz6eGCPWrZbACyQ1AP4HOli1q+0YlQzs1bnHiyz9q8bsLIB21VmX6/LhgS9PyxI0gaSfi7pDUmrJU2TtHf+zpL2kzQlG4q4RNLTkv63vrbrImlbSfdJejdr9yVJ38lbXzhcLWq5HZa3zW6SHpNUlQ0ru1pSRQOenzpFRE1z26hNNnwuJG0n6YHsuXhZ0pca0UZXSRdLej17DedJujM3lC7vGDvlDet6RdKB9bT7/hDBbLjpPdmq2Vl7c7J1/SRdkx33vSzH1U14OhriHdLPfbNJOljSq9nz8YikcUV+pr4h6Yns53RJtt34gnaulzRZ0gHZa/dets82jciysaRbJS3K8sySdG7hMfLuz6nl/XBW3jajJd0rqTK73SZpSFOfr3yNLG5zF9cuyetmZtaWucAy68AiQhHxaHY39x/m84Cds9v8bNntpKFHPwX2BZ4B7lZ2TpWkzbNtHs7WHwL8FdiwAW3X5R5gHXAosB9wOVBXMbRzwe1yIIDXspy7Ag+ShvF9GfgusDfw/rlpEfFoRCi/0eyD6vUNyFsSEXF9RIwqsupm4G7gQOBV4E+SNm5gsz8gvS4/Aj5LeuzLgM4F290C3AV8CXgeuE3SmAYe41ng1Oz7L5Feg1yBdgnwKeBk0pDCM0ivDVD8MRcWA3WR1FlST0mfAk4Eft3Y3quIOCsids9rczxpCNuz2eO4m/T8FBoF3AAcDHwNeAN4XNJmBduNJD0P52bb9QXuV8OHxd0AbAIcRRpWdz7QvY7tD+TD74czsuWvZI9vC+BfwAak99hhwLbAPZIEEBFzst8Tc3KNZv/YeLSBmc3MrICHCJq1f/1oWA/WM9nXWRHxVG6hpD2BLwK7R8Rj2eJ/SNqKdK7LwcA4oDIiJuW197f62q6LpIHApsD+EfF8tvihuvYpyL0jcCRwdkQ8kS2+AHgyIibkbfcW8JCk0RExo5amq0mFXrn9IiKuBZA0BVgI7AP8pgH7fgK4OSJ+n7fs1iLbXRMRF2fHuB94kVScfbW+A0TEckkzs7tT8z+UZ8e/IiLyC5Qb62lyHdDQnsGVfFBs3ABMqmPbhjoNeAn4alas3SepK3Bh/kYRcU7ue0mdgAdIj/dQ4Jy8TQeSfp6fzLadAswiFTYNfQ0nRkSul/DRujaOiKl5uUYCpwDXR8TN2eKfkP7ZsFdErMm2mw68TPrHw721NN0S74Wq7GvfFmjbzKxNcQ+WWTslqZekb5E+sExpRlOfIX0I+5ekLrkbqdjJDYN6Hugr6feSPiepV7PCJ++SegJ+I2mCpMEN3VHSIODPpN6qc7JlPUn/xb+14HE8AawFdqytvYjYIiKOaPpDKZl/5L6JiHeARUBDe7CeAw6T9H1J2+d6KIq4M+8YNaTerE80Le5Hjj9J0nFZcV6viOiSX7zUYxdgN+B7wP7Ar5qU8sN2Au4p6Am7u3AjSR/PhlsuJBUfa4GtSec/5luUK64AImIu6b3Z0Of3OeBn2XDOEQ19EErnN90JzAWOzVv1mWx5Td77YTYwhw/e2x8REXtGxJ4NPX4DvUQqko+WNKCOn08zs3bPBZZZO6R0ftMK4HfA5RHxkQ+FjTAQGEL60Jh/O4s0XImImEn6ULsZqedqsaSbs0KnSbIP958jFXfXkk6Ef1zSuLr2yz4k3gqsAQ7N+3DcnzQc7sqCx7Ea6Jp7LG3c0oL7a0jDuxriPOAK0syL04A3JJ1UZLtFRe4PbUTG2hwP/AX4MTAzO6+p3l6xhoqIZyPiiYi4hDRE8Nhs6GpzDAHeLlj2oftK5+/9g/TzcwqpyNuJ9BwXvjaFz21uWUOf3wnAZOAXwFxJz2U9zPW5Kst3UES8l7d8IKmXrvC9vRmt/H6IiErSsMkvA4uBb7bm8c3MWpOHCJq1T/NIH/S+Ahwn6aaIeLqJbb0LvAUcUNdGEXEvcK+kvqQhhZeSzoFq8ofoiHgZOCgblrUbaWjWvZI2rmNSiYtJH3A/GRHL8pYvJZ3zcxYfHr6YM6+pOduD7IP1j4EfS9oSOAa4VNLMiLgvb9PBpEki8u835Hy5+o6/lFT4nChpe+D7wE2SprfAbJDPZl83JQ3Ba6oFQOE/CQrv70zqRfxs9vMKQPY+KFSsF3Yw8EJDwkTEW6ReyE6kXq+zSOdCjsh6ND9C0neBicAXsh6zfO+SerCuKbLr4iLLWkz2Hv8VqYA8B5ha9x5mZu2Xe7DM2qGIWJOdd3QKqYfmcw3YbU32tfC/7g+R/pO/IiImF96KHHtZdo7HnUBuhrTa2m6QiFgbEQ+TJggYSi3XWJL0deAk4IjC86kiYiXwFLB1sccRER26wMoXEa+SJqNYzQevUc77swZmH+T3B/7TiObrfa0jYjrpHKlOwMca0XZD7Zp9nd3Mdp4B9i0YrrZfwTY9sq+rcwsk7UKa+KLQ4GxdbrsRwA407vklImqy8w3PJl1vamSx7SR9GrgIOCMiHiyyyUOkSS2mFHk/zGlMphIYTeo1OzsiHqytYDQz6wjcg2XWjkVEtdIU2n0asO0aSbOBr0iaAbwHTCedsH8/8ICkC0n/be9DumjwBhHxA0lHk/6Tfx+pJ2hL0uQXN9TVdu7E+mKyXo6LSbO2/Zc0xO80YFpEvFtk+81JQ6H+Tho+9cm81bMi4m1Sr8lDkmpIsx5Wkq6780XghxFR9Po7kl4DHqvvPCxJuWtfbQX0zLv/WHZ8stkId69llsAWI+lO0vk+U4FVpKFYXYB/Fmz6bUlrgBmkC8VuQeoBaajcJBdHS/oTUBURz0t6glR0zyD1JB5JOuem1uJCUjVwTl3nYUm6j3Su3Quk8592JZ2HdUvkXRcqN+td/iyBDXAh8DRptsbrgI9nueGDyTeeIg3HvVrSz0m9WWeRen0LLQZulHQm6TU4mzRE8Pr6gmQ9YveT3lOvkCb0+B6pl+2lWra/lfR8/7Pg/fBmpOuXnUV6/u+VdG2Wbzhplsnr82YYLWz7IUjnYtWTeS+gF9kFxvPeD88U6U3L/Y4qNozSzKxDcYFl1v4F0NATxo8hFTUPkj7AbRoRc5Sut3QGaWrvEaShRc+RhgBCKsT2I/UwbUgaUnY1aUharW2TTqavzQLSLHk/BIaRhvg9QiqyitmE1GuyV3bLdzjpA+MTkv4f6YPtH0jnZM0lFYYL68jShY9OZ17MbbXc/zQfzPjWk/J8iHySdA5PrufoRdI5OYW9kF8lneNzHmmSkQn5s9HVJyLmSjqVNBzwBNJFiEcB/ybNljeKVAhNJc1eV9dFijtT/0iKZ/LarSYV4z/go7Py9aTun7ePiIjJkiaSLk+wP2n42rGkfzosz7ZZKOlg0s/2XaTp848hFfOF5mZtXUDqdZoMfK3gvKjavEeaTOYk0s96Fam4+1xErCqyfX/SOVYDSc99vrOBsyLilazwOo/0z4kepMLwIbJLG9SiIe8FgF/z4d613PvhcD5aVOZ+R603F4Y2s/WXonGXETGzNkbSLOBvEXFCubMYSJoL/LhguvSyU7pw7nVARUSsqGfzdkVSd1JB9Lm8Sw00ta1DScX5ZhHR4CGIWc/l6IiodXa+9Zmkz5P+0fHx/HPZzMw6IvdgmbV/bwKfkjQMWFDH5BDWwiQNJ81Y+MdyZ1nPjAeeb0pxJenXpB6rJaTzpc4E7m1McWW1y85vqyD1gNfQwSebMZsyZUq3Tp06Hdu5c+fDI6IvDR9hYu1DSFq2bt2662pqan694447Fj0VwgWWWft3CXATaejP70nDqcoum0Ch1uFfEVHdinFaRTYL3LBSt5t9SK1r2FbN+lxYR8S/qOO6TvUYQJrafwBpdsVbKD78r1nqez8A66JjDik5iTQktQb4ZUQsL3MesxbVpUuXq/v06bPrsGHDVnbr1u0dX/KtY4kI1qxZ03XevHknLF++fAdqueSEhwiadQCSNgA2B1aWYXaworIhU3Vd62bTtpK1rZO0O+n8tNqcHRFntUoYaxJJZwE/qWOTT9c26UR7ll1AfAjwRkQsKXces5Y2bdq0Wdttt93STp06+QN2B1ZTU6Pnn3++35gxY4pej9E9WGYdQHYSfYOutdOKziJd96Y2HirUcFNI1/6qjZ/Ltu8q4K91rJ9Zx7p2KyIW4ZkDbf3S2cVVx5e9xrWOLHEPVhEDBw6MUaNGlTuGmZmZmZXRlClTFkdE4QXIazVt2rQ5Y8aMadULeVt5TJs2beCYMWNGFVvnHqwiRo0axeTJH7m+qpmZmZmtR7KZYc0axQWWmZmZmVkL+ukf14ypWt3yn7t7dqf6jIndprX0cQr9+te/3vDSSy8dMnPmzBdbYvv2pr4LPJqZmZmZWTO0RnHVmOP07NlzXO7WpUuXHbp06bJD/rLGHvfYY499tzHFUmO3b00zZ87sJmnHWbNmdW1qG+7BMjMzMzNbj1RVVU3NfT9hwoSR1dXVuuOOO+YU23b16tXq3r27J21oBPdgmZmZmZkZAJ/4xCe2/ta3vrXJZz7zmc179+497uyzz95o1qxZXXfbbbct+/fvP6aiomLsjjvuuPXjjz/eM7fPZZddNmDEiBGj89s48sgjN/785z+/ea9evcZtsskmo2+88cZ+Td2+pqaG008/fchGG220fd++fcceccQRm+y8885bnXLKKUWvPblq1SpNnDhx5IYbbjimd+/e40aOHDn62muv7Z9bf9999/Xecccdt+7bt+/YTTbZZPRPfvKTjWpq0uUkx48fvw3A6NGjR/fs2XPcpEmThjb2OXSBZWZmZmZm77v11lsHnnjiiYuWL18+9Qc/+MGimpoaHXPMMYtef/315+fPnz9t++23r5owYcLmq1evrvVKyrfffvuAU089dcHy5cunfvvb31507LHHjqqsrKy19qhr+yuvvHLA1VdfvdGf//znVxctWjRt6NCha5555pnetbV1xRVXDHjuued6vfjiizNWrFgx9aGHHpo5ZsyYVQBTpkzZ4KCDDtry5JNPXvjOO+88d/fdd792zTXXDL7yyisHAEyePPlFgBkzZsyoqqqaetFFF81v7PPnAsvMzMzMzN631157Ldlvv/0qO3XqREVFRc2WW2655pBDDllWUVFR07t377jkkkvemj9/frcZM2Z0r62NffbZZ8lnP/vZlZ07d+bkk09evGLFis5N3f7mm28e8PWvf/3tXXfddVX37t3jnHPOWTh48OC1tbXVrVu3qKqq6vTcc8/1WLt2LVtsscXaHXfc8T2AX/7yl4P33nvvJYceeujSLl26MG7cuPe+/e1vL7r55psHNOc5y+dzsMzMzMzM7H0jR45cnX9//vz5XY477riNn3rqqYrKysoukgJgwYIFtdYSQ4cOfb8A6tOnTw3A8uXLa704b13bL1iwoOvIkSPX5NZ36tSJoUOHrvloK8mxxx77zsKFC7ueeuqpm8ydO7f7zjvvXHnJJZe8OXr06NWvv/56t6eeeqpPRUVFv9z2EaEhQ4bU2l5juQfLzMzMzMze16nTh0uEk08+efjChQu7PvXUUy+vWLFi6uuvvz4dUmHSGnmGDBmydu7cud1y92tqapg/f3632rbv2rUr559//oIZM2a8NHv27Od79OhRc9hhh40C2HjjjdccfPDBiysrK5/L3VasWDH1tddeewE++tibwgWWmZmZmZnVqrKysnOPHj1qBg0aVL1s2bJOJ5xwwsatefyJEye+c+ONNw568skne6xevVpnn332RosWLap1GvW777674vHHH++5evVq9erVq6ZXr141nTt3DoCTTjpp0T333LPhzTff3Hf16tVau3YtU6ZM2eDee+/tDaknrVOnTrz44osbNDWvCywzMzMzsxbUszvV7fk4P/3pT9965513ug4YMGDstttuu+0uu+yyonPnWkf7ldx3vvOddw4//PBFBxxwwJaDBw8e8+abb3YbM2bMyu7du9cU237+/PldDzvssE379+8/dsiQIWPeeOONbtdcc81cgJ122um922+//dXLL798oyFDhmw/cODAsYcddtimuYKtd+/eMWnSpLcOP/zwzSoqKsaedtppQxqbVxGe1r7Q+PHjY/LkyeWOYWZmZmZlJGlKRIxv6PbTpk2bM2bMmMUtmclg3bp1DB06dPtzzjnnzWOOOebdcmSYNm3awDFjxowqts49WGZmZmZm1qZdddVV/auqqlRZWdnplFNOGfbee+91Ouigg5aVO1cxLrDMzMzMzKxN++1vfzt4o402GjNs2LDtH3/88T5//vOfXx00aNC6cucqxtO0m5mZmZlZmzZlypSZ5c7QUO7BMjMzMzMzKxEXWGZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEvEsgmZmZmZmLWjpJaeOiVUrW/xzt3r0qu53ysXTWvo4jbHFFltse9ppp8078sgjl5Q7S2txgWVmZmZm1oJao7hqzHF69uw5Lvf9mjVrBNCtW7fILauqqpra2GPPnDmz28c+9rHtXnvttembb7752tzy11577YXGttVaDjrooFFdunSJW265ZW4p23WBZWZmZma2HskvoCZMmDCyurpad9xxx5wyRupQfA6WmZmZmZkB8Oqrr3b7whe+sNnAgQPHDBo0aPuJEyeOXLJkSSeAmpoaTjjhhOGDBw/evlevXuOGDx++3fnnnz8YYPz48dsAjB49enTPnj3HTZo0aSjA8OHDt7vyyis3BPjrX/9a0aVLlx2vvvrq/ptsssnoioqKsXvvvfdmufYBpk+f3n2nnXbaunfv3uO23nrrbc4999zBknasLe9f/vKXio9//OPb9O7de1z//v3H7LLLLlvl1lVWVnY66qijNh4+fPh2ffv2HbvbbrttOWPGjO4AZ5555kZ33XXXhnfccceAnj17juvZs+e46urqkjyHLrDMzMzMzIyqqirtueeeW33sYx97b86cOdNffPHFF+bNm9f1qKOOGgHwl7/8pc+tt9464Mknn3xp5cqVU//zn/+8tPvuu1cCTJ48+UWAGTNmzKiqqpp60UUXzS92jHXr1vHAAw/0mTFjxosvvvjijBdeeKHnBRdcMBhg7dq17Lfffltuu+22VQsWLHjuzjvvfO2GG24YVFfmo446atNjjjlm4fLly6fOmzdv+hlnnPH+cQ855JCRr7766gZPPfXUSwsXLpw2fvz4lfvuu+8Wq1ev1nnnnbdw//33f/eggw56p6qqampVVdXULl1KM7jPQwRL5Nw/Nq3i/dHE1nkJmpoP2n5G50vaej7r+JZf8t0m79vnlEtLlqMuTc3YWvnMzMrplltu6RcRXHrppfMAevfuve68886bt+eee36surp6Trdu3WLNmjV67rnnegwbNqx6+PDh1cOHD2/0B5BLL730rb59+9b07du35gtf+MLSZ599thfAww8/3HvevHndfvWrX73Zu3fv2GabbdYcd9xxC0855ZSRtbXVtWvXmDVrVvc333yzy4gRI6r32WefSoD58+d3ueeeezZ85ZVXnt9kk02qAS6++OJ511xzzeBHH3201+c///kVTXuW6tfhe7AkdZZ0kaS3JVVKukPSwHLnMjMzMzNrS/773/92mz9/freKioqxudvee++9lSTeeOONrvvss0/lD3/4w7d+9rOfDR08ePDYXXfddct//vOfPRtzjM6dOzNs2LD3i7JevXrVrFy5sjPA66+/3nXDDTes7t279/sTbmy66aar62rv9ttvf23WrFkbjBkzZtvNN99823POOWcwwCuvvNINYIcddtgm91j69es3trq6WnPmzOnWmMyNtT786/p0YH/gf4B3gGuBPwB7lTOUmZmZmVlbMnLkyDWjRo1aXdfMf6eeeuriU089dXFlZWWnSZMmDZswYcLm8+fPf75Tp+b324wYMWLtkiVLuqxYsUK5Iqu+YmjnnXdede+99/63pqaGf/zjH70POOCArcaOHbtqxx13XAUwc+bMGfkFXb5SZC7abou02rYcBVwYEf+NiGXA94EvSKq1q9HMzMzMbH0zYcKEZWvXrtXpp58+ZMmSJZ1qamqYPXt21xtuuKEfwCOPPNLzvvvu671q1Sr16NGjpqKiYl2uSBk6dOjaTp068eKLL27Q1OPvscceK4YOHbrmxBNP3Liqqkovv/xytyuvvHKj2rZ/7733dPnllw+YP39+l06dOjFgwIBqSdG5c+cYPnx49b777vvuEUccMWL27NldARYvXtz5hhtu6Lds2bJOABtttNHauXPndl+3bl1TIxfVoQssSf2AEcCU3LKImAUsB8aUKZaZmZmZrUfUo1dppqdr4eNUVFTUPPTQQzNfeumlHltvvfXoPn36jNtjjz22mjp1ak+AysrKzqeccsomAwcOHNu/f/+xDz/8cJ8bb7xxFkDv3r1j0qRJbx1++OGbVVRUjD3ttNOGNPb4Xbt25c4773xt+vTpPQcNGjR2//3332LChAnvdO3aNWrb5/bbb++/zTbbbNuzZ89xBx544JaTJk2a98UvfnEFwE033TR3yy23fG/33XffulevXuNGjx697W233dZfEgDHHXfc21VVVZ369+8/tqKiYmypZhHs6EMEK7KvywqWLwX65C+QdBSpt4sRI0a0eDAzMzMzWz/0O+XiaeXOUJvCi+xuscUWa++6667Zxbbdb7/9Kvfbb7+XamvrggsuWHDBBRcsyF/21ltvPZ/7fp999qmsrq6ekr/+kksumZd/f9y4ce9Nnjx5Zu7+RRddNHDYsGFrih1vgw02iMcee+y12vJUVFTUXHbZZfMuu+yyecXWb7PNNmumT5/+cm37N1WH7sECKrOvfQuW9yP1Yr0vIq6KiPERMX7QoDpngzQzMzMzsxZw//33937hhRe619TU8PTTT/e47LLLhhx44IHvljtXY3ToHqyIWCrpdWAH4DkASZuReq+mlzGamZmZmZkVmDNnTrfDDjts06VLl3bp379/9T777LPk/PPPL3pNrbaqQxdYmauA0yQ9QppF8ELg/oiYU9ZUZmZmZmb2IUcfffS7Rx99dLvqsSq0PhRYFwD9gWeA7sADwKFlTWRmZmZmZh2SImqdlGO9NX78+Jg8eXK5Y5iZmZlZGUmaEhHjG7r9tGnT/rvddtst6dSpkz9gd2A1NTV6/vnn+48ZM2azYus7+iQXZmZmZmatQtKCVatWNfk6UNY+rFq1agNJC2pb7wLLzMzMzKwEqqurz54zZ063lStX9qipqVG581hp1dTUaOXKlT3mzJnTrbq6+uzatlsfzsEyMzMzM2txO+yww/3PPvvs8bNmzfpJRAzBnRkdTY2kBdXV1WfvsMMO99e2kQssMzMzM7MSyT541/rh2zo+V9VmZmZmZmYl4gLLzMzMzMysRFxgmZmZmZmZlYgLLDMzMzMzsxJxgWVmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZibjAMjMzMzMzKxEXWGZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZmZmZmVmJuMAyMzMzMzMrERdYZmZmZmZmJeICy8zMzMzMrERcYJmZmZmZmZVIl4ZsJEnAV4HxQEX+uog4qgVymZmZmZmZtTsN7cH6NfArYBOga8HNzMzMzMzMaGAPFnAw8ImImNWSYczMzMzMzNqzhvZgVQGvt2QQMzMzMzOz9q6hBdbPgR9n52KZmZmZmZlZEQ0dIngiMBI4QdKi/BURsVXJU5mZmZmZmbVDDS2wzmvRFGZmZmZmZh1AgwqsiPh9SwcxMzMzMzNr7xrag4WknYBvkaZqfwO4NiKeaalgZmZmZmZm7U2DJrmQdADwT6AvMBXoAzwm6cCWi2ZmZmZmZta+NLQH6yfAQRHxt9wCSXsBFwB3tkQwK61z/1jd5H1/NLHBHZ3N0tSMzpe09XzQ9jM6n5Xb8ku+26T9+pxyaUlz1Kat5zMzawsaOk37KOC+gmX3k2YWNDMzMzMzMxpeYM0FPlOwbE/a+MWHJX1V0uOSlktqeheOmZmZmZlZAzR03Mi5wF2Sbgdmk3q0DgK+2UK5SmUJcCXQA7iqzFnMzMzMzKyDa+g07XdImk8qqMaTZhH8bEQ82ZLhmisi7geQtHt5k5iZmZmZ2fqgwWc+Z8VUmy6omkPSUcBRACNGjChzGjMzMzMza49qLbAk/U9EPJ19v0tt27X1XqyGioiryIYRjh8/Psocx8zMzMzM2qG6erAeBCqy75+oZZsAOpc0kZmZmZmZWTtVa4EVERV53zd0tkEzMzMzM7P1VoMKJ0lfr2X5IaWNU1qSOkvaAOiW3d8gu6nM0czMzMzMrANSRP2nG0laHhF9iix/NyI2bJFkJSDpMOC6Iqs2jYg5te03fvz4mDx5ckvFMjMzM7N2QNKUiBhf7hzWvjR06N9HenwkjQLa9MV7I+L6iFCR25xyZzMzMzMzs46nzmnaJa0lm8hC0pqC1Z2BX7dUMDMzMzMzs/amvutgfYbUe/U3YK+85TXAgoh4taWCmZmZmZmZtTd1FlgR8RiApM0jYn7rRDIzMzMzM2uf6uvBAiAi5ksaAOwEDCLvnKyIuKGFspmZmZmZmbUrDSqwJH0GuANYA/QDlmZfZwMusMzMzMzMzGj4LIIXAOdExCBgRfb1XOA3LZbMzMzMzMysnWlogbUlcGn2fW544IXAd0ucx8zMzMzMrN1qaIFVBXTPvn9H0gigG9C/RVKZmZmZmZm1Qw0tsJ4EDsi+/ztwN/Ag8O8WyGRmZmZmZtYuNWiSC+BQPijGTgW+B1QAl7REKDMzMzMzs/ao3gJLUhfgYlJRRUS8B5zfwrnMzMzMzMzanXqHCEZENfBVYHXLxzEzMzMzM2u/GnoO1t3AQS0ZxMzMzMzMrL1r6DlYXYEbJR0DzAFqcisi4qgWyGVmZmZmZtbuNLTAWgv8Mfu+c3YzMzMzMzOzPA0qsCLi8JYOYmZmZmZm1t419BwsJPWV9DVJ38/uD5E0rOWimZmZmZmZtS8NKrAk7Qi8BpwO/ChbvD1weQvlMjMzMzMza3ca2oN1KfD9iNgeqM6WPQl8siVCmZmZmZmZtUcNLbC2Ba7Pvg+AiFgB9GqBTGZmZmZmZu1SQwust4ER+QskbQG8VfJEZmZmZmZm7VRDC6zfA3+S9ClA2TlZ1wBXt1gyMzMzMzOzdqah18G6kDQc8G9Ab+AR4Jd4kgszMzMzM7P3NfQ6WOuAHwI/lDQwIha3bCwzMzMzM7P2p6HTtN+X+z6/uJJ0b0uEMjMzMzMza48aeg7WLrUs9zTtZmZmZmZmmTqHCEr6Wm47SRMB5a3eEljSUsHMzMzMzMzam/rOwTo/+9od+Gne8hpgAXBCS4QyMzMzMzNrj+ossCJiUwBJd0fEfq0TyczMzMzMrH1q0DlYLq7MzMzMzMzqV2sPlqTLIuLE7PuratsuIo5qiWBmZmZmZmbtTV1DBLvW8r2ZmZmZmZkVUWuBFRHH5n1/eOvEMbOO7Nw/Vjdpvx9NbNA10ZvN+Zqnqfmg7WdsrXzWPMsv+W6T9+1zyqUly1GXpmZ0vqSt5zODhl8Hy8zMzMzMzOrRoQssSRdKekHScknzJF0tacNy5zIzMzMzs46pQxdYwDrgUGAAMAbYGLi+nIHMzMzMzKzj6tCDyiPijLy7b0v6JXBrufKYmZmZmVnHVmcPlqS7Je0tSa0VqIXtCUwrtkLSUZImS5r89ttvt3IsMzMzMzPrCOobIvgOqcdnjqQfSRrWCplahKSDgGOAk4qtj4irImJ8RIwfNGhQ64YzMzMzM7MOoc4CK5uefRjwc+BLpELrLkl7tadeLUkHA1cD+0XEs+XOY2ZmZmZmHVO9k1xExPKIuCIixgG7AYtJvVqzJZ3Z0gGbS9LhwG+BfSPikXLnMTMzMzOzjqtRswhGxNMRcQSp0FoHnN0iqUpE0onAxcDnI+Jf5c5jZmZmZmYdmyKiYRtKXYADgaOATwP/An4bETe3XLzmkRRANbA6f3lE9K5rv/Hjx8fkyZNbMpqZmZmZtXGSpkTE+HLnsPal3mnaJW0FHAl8I9v+98AJEfFyC2drtohoN+eJmZmZmZlZ+1dngSXpMeBTpN6q7wG3RcTquvYxMzMzMzNbX9XXgzUVOCYiXmqNMGZmZmZmZu1ZfZNcXABsV2yFpK9IGlz6SGZmZmZmZu1TfQXW94Eta1m3GXBaaeOYmZmZmZm1X/UVWHsD19Sy7jpgn9LGMTMzMzMza7/qK7CGRMTCYiuy5UNKH8nMzMzMzKx9qq/AWiNpaLEV2fK1pY9kZmZmZmbWPtVXYP0LOKGWdd8BHi9tHDMzMzMzs/arvmnazwcelzQI+CPwFjAcmAgcQrpGlpmZmZmZmVFPgRURkyXtB1wBHAEEIOA1YL+IeLblI5qZmZmZmbUP9fVgEREPAFtJ2hIYBLwdEa+2eDIzMzMzM7N2pt4CKycrqlxYmZmZmZmZ1aK+SS7MzMzMzMysgVxgmZmZmZmZlYgLLDMzMzMzsxJxgWVmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZibjAMjMzMzMzKxEXWGZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZmZmZmVmJuMAyMzMzMzMrERdYZmZmZmZmJeICy8zMzMzMrERcYJmZmZmZmZWICywzMzMzM7MScYFlZmZmZmZWIl3KHaCjGHX6vU3ab84FXyxxkuK2+/12Td73+W8+X8IktWtqRudL2no+gCuOebhJ+33nN3uUOElxztc8b57+eJP33fiC3UqYpHZNzdha+R56ePMm7bfnHrNKnKS4tp7vulfnNXnfw7ccVsIktWtqRudL2no+M3APlpmZmZmZWcm4wDIzMzMzMyuRNllgSepa7gxmZmZmZmaN1WoFlqQhku6RtEzSK5KOkBSSRkm6XtJN2dd3gcuyfY6VNDPb5ylJu+W1d5akBwuO8aikM7Pvd5dULembkuZKejdrv3drPWYzMzMzM1u/tGYP1k3AGmAT4FPA1wvWHwz8HRgEfE/SROBc4BvAAOBq4D5JIxtxzM7AvsD2wMeBrYBLim0o6ShJkyVNfvvttxtxCDMzMzMzs6RVCixJGwN7AJMiYnlELCIVT/meiIhbImJdRFQBhwO/jYinI6I6In4HTAe+1sjDnxYRyyJiIfBj4BuSPvK4I+KqiBgfEeMHDRrU6MdoZmZmZmbWWj1Yw7Ovr+ctm1uwzZyC+5sAswuWzcqWN0b+ceYA3YGBjWzDzMzMzMysXq1VYL2VfR2Rt2xEwTY1BfffAEYVLNssWw5QCfQqWF/sIgf5QwpHAauBxbVHNTMzMzMza5pWKbAi4k3gUeACSRWSBgFn1rPb9cDRkj4hqYukw4GxwM3Z+inADpJ2zNYfD2xapJ2fSeojaTBwFvCHiCgs5szMzMzMzJpNEdE6B5KGkiaq2A1YCPwCuJLU6/QzoDoivl2wz/HAicBGwEzg+xHxaN76nwG5fX6Ttf1gRJwnaXfgQeAI4BygD3AP8J2IqKwr6/jx42Py5MnNeLRmZmZm1t5JmhIR48udw9qXViuwPnJg6fPAXUCPaIEQuQIrIro0dl8XWGZmZmbmAsuaotHFR1NJGks6z+p50lC+84BbWqK4MjMzMzMzK4fWvA5Wf+DPwArgCdKU6ye14vHNzMzMzMxaVKv1YEXEI8AWrXi8R2nFx2dmZmZmZtaaPVhmZmZmZmYdmgssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZmZmZmVmJuMAyMzMzMzMrERdYZmZmZmZmJeICy8zMzMzMrERcYJmZmZmZmZWICywzMzMzM7MScYFlZmZmZmZWIi6wzMzMzMzMSsQFlpmZmZmZWYm4wDIzMzMzMysRF1hmZmZmZmYl4gLLzMzMzMysRFxgmZmZmZmZlYgLLDMzMzMzsxJxgWVmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZiSgiyp2hzZH0NjC3hE0OBBaXsL1Sa+v5oO1ndL7ma+sZna952no+aPsZna/52npG52uelsg3MiIGlbhN6+BcYLUCSZMjYny5c9SmreeDtp/R+ZqvrWd0vuZp6/mg7Wd0vuZr6xmdr3naej5bf3iIoJmZmZmZWYm4wDIzMzMzMysRF1it46pyB6hHW88HbT+j8zVfW8/ofM3T1vNB28/ofM3X1jM6X/O09Xy2nvA5WGZmZmZmZiXiHiwzMzMzM7MScYFlZmZmZmZWIi6wzMzMzMzMSsQFVguS1FnSRZLellQp6Q5JA8udK0fSVyU9Lmm5pOpy5ykk6UJJL2T55km6WtKG5c6VT9L5kmZnGRdJul3SiHLnKiSpk6QnJYWkjcudB0DS9ZLWSlqRdzuu3LmKkfQZSU9lGRdLurLcmQCy90f+87cqe413KHe2HElDJN2S/R5cIulhSWPKnStH0gBJv5e0QNIySTdL6l/GPHX+Xpb0hex1XyVphqTPtZV8koZLukvS3Ozn8NDWzNbAjHtnP4OLs5/HxyXt1oby7SbpWUnvZj+Pz0r6UlvJV7DdsdnrfGZr5suOXddzuHuWK/9345OtndHWby6wWtbpwP7A/wC5D7V/KF+cj1gCXAl8t8w5arMOOBQYAIwhPYfXlzNQEX8AxkZEH2AU8Drwp7ImKu5koKrcIYr4fUT0zru1icIln6TdgduBi0k/ixsD15Qx0vsiYtv85w+4BHgxIp4td7Y8VwIbAlsBGwGTgb9KUllTfeAGoDewJbAp6TUu5+/pWn8vS9oM+DPwM6Bv9vVOSaPaQj6gBvgH8DXgzVbMVKiujP2By4EtgEHAzcDfJW3SaunqzjcTOJD0c9gv2+ZGSR9vpWzQgM8GkkYC3wOeb6VMherLuK7gb8surRfNDLqUO0AHdxRwTkT8F0DS94HXJI2MiLnljQYRcT+8/wGyzYmIM/Luvi3pl8Ct5cpTTES8nHdXpA8YW5cpTlGStgKOAw4CppY5Tnv0M+A3EXF73rK2VMAAIKkL8C1S3rZkC+BXEbEEQNLvgEmkD5CLyxlMUi9gL2BcRFRmy34KPCppRES83tqZ6vm9/E1gSkTcmN2/SdIx2fKzy50vIuYDV2Tr17VGnmLqyXhTwaJfS/oJsBPwRouHo958i3LfS+pE+pvSifQ+eqnc+fL8DvghcGwrRPqItv75xcw9WC1EUj9gBDAltywiZgHLSb0x1nh7AtPKHaKQpK9JWgasAE4Czipvog9kf6CvBU4FlpY3TVEHZUNhXlEaTtu73IHyZR/APwF0yYbqLJb0qKTx5c5WxAGkXo0bypyj0EWk13mQpA1I/3h6IiLKWlxllHfLyf1dHNvqaeo3hry/KZln8d+UJpO0HTCQ8vXEFCVpKbAaeBx4mtQz2CZIOhpYGRG3lDtLHTpLeiMb+ntvWxqWbOsHF1gtpyL7uqxg+VKgT+tGaf8kHQQcQypg2pSIuDki+gJDScVVW/pDfRKwICLuLHeQIi4HPkb6cHMg8L/A1WVN9FH9Sb8nJwKHAcNIH3T+lv0TpS05GrglIpaWO0iBfwGdgUWkf0J8CTiyrIkyEbECeBQ4S1I/SYOAXM95W/w9XYH/ppSMpMHAHcDFEfFqufPki4h+pKGrBwJ/A9rEedJK5xifSRoV0Va9TPoHyaakvzHTgYclDStnKFu/uMBqOZXZ174Fy/uRerGsgSQdTPrgvV8bO7fkQyJiASnnX9UGJuOQtAVpjPzx5c5STERMiYiFEVETES+QzhP7sqTu5c6WJ/c+vi4ipkfEGtIQvK5AmxnTL2lzUg/vb8qdJV/Wg/og8Arpd2FP4HzgcUkblTNbnkNJPQUvAf8B7sqWt4UetkKV+G9KSWQfth8h/cPkB2WOU1RErI6Iv5D++fTtMsfJuQY4LyLeKneQ2kTEgoiYFhHVEbE0In4AvEsaDmzWKlxgtZDsv8ivA+/P5pWdoNyH9N8UawBJhwO/BfaNiEfKnacBugC9SD0d5fYp0kncMyQt5oPzhqarbc7WV5N9bSuTHxARy4A5QBSuKrKsnI4GpkXE0+UOUmBD0n+RL4+I5RGxJiKuIf3t2bm80ZKIeCsiJkTE0IjYFJgNvAc8VeZoxUwj729KZhxtcOh0W5ZNCvI48PeIOD4i2tJ7uZgupElY2oLPAj/NhksvBnYFfiDp8TLnqk8Nbehvi3V8LrBa1lXAaZI2ldQHuBC4PyLmlDdWojSN/AZAt+z+BtmtTfwSknQiaea2z0fEv8qdp5DS1OfHZ8NMUJr+/ArSB/KX69q3ldwKbE4aKjEW2Dtb/jnawHk62TS7/bLvtwT+D7g7It4ra7CPuhI4XNI22UQSk0g9Hm1i2l9J3UjDF9tU7xVAdp7VK8BxknpJ6iLpW6Shbm3iH02Stpa0YfZ+3gm4FLigXEMt6/m9fAMwXtJESV0lTQR2BH7fRvK9f5/0YbZrdr9VJ9SqK6OkjwFPAH+MiFNbM1cD8x0kabvsvbKBpCOBPYD720I+YBPSOX9js9tk0t+9L7dWvvoyStpD0hbZe7q3pLNIM5i22nNoRkT41kI30nkHF5OGmlSSptcdWO5cefkO44P/xOffRpU7W5YvgLWk8zbev5U7V16+TqSx8YuAlcBbwE3A5uXOVkveUdlzunG5s2R5HiUN21hJ6jW4BOhT7lxFcgo4B1hAOt/lEdLU/GXPluX7KmmIWO9yZ6kl38eBv2a/B5eRJmnYv9y58vIdCcwnXcbgVeCkMuep8/cy8AXgBWBV9vVzbSxfsXVntZWMwHXZ9ysKboe0kXzHZz+HK7Lfj/8GDm4rz1+RbR8FzmzNfA14Dk8G5mZ/WxYB9wE7tXZG39bvmyLaes+4mZmZmZlZ++AhgmZmZmZmZiXiAsvMzMzMzKxEXGCZmZmZmZmViAssMzMzMzOzEnGBZWZmZmZmViIusMzMzMzMzErEBZaZ2XpM0lmSHmzG/mdIuqeZGV6TdFhz2jAzM2srXGCZmbUSSZtJuk3SAkkrJL0h6U5J3cqdraki4qcRsW+5c5iZmbUVLrDMzFrP34D5wNZABbAzcD+gcoYyMzOz0nGBZWbWCiQNIBVWv4mIZZG8GRG/iYjV2TZjJD0mabGkJZL+LmnzvDaul/QHSddKWirpLUkTJY2V9IykSkmPSBqWt88cST+W9ETWazZZ0k515Owp6WJJsyW9K+k+SVvUsf2HhhhmxztD0kPZ8WZI2iVvfVdJl0halPXknVakzd2yvO9KmiXpe5KUrfuDpH9I6pTd313ScknbNfS1MDMza0kusMzMWkFEvAO8AFwj6RuStskVDfmbAWcBw4FRwArgxoJtvgzcAWwInAtcDZwDHAhslLVxdsE+xwAnZfvcDvxNUp9aol4NfAz4JDAEeBr4q6SujXi43wJOBPoCDwC/z1t3OrAPsAuwafY4R+ZWStqG1NN3ETAI+CJwPPD1vMeyMXCmpI2APwInRcTzjchnZmbWYlxgmZm1nt2BR4HvAs8BCyX9KFdoRcT0iHgkIlZHxDJSofRJST3z2ng4Iu6NiBrgBqAX8IesN6yKVECNLzju7yJiSkSsAS4EVpGKnA+RNBD4GnBcRCzMtj8bGAr8TyMe528j4oWIWAdcA2whqW+27hvAhRHxWkSsAk4lFYU5xwG3RcRdEbEuIl4GfpXtR0SsBA7O9nsAuC8irmtENjMzsxbVpdwBzMzWFxGxGDgDOCMrmr5C6jF6C7g2Gw54EamYqeCDwmMQMDf7fn5ee1VZbfb+MqAq2zffnLx9QtLrpF6gQptmX6cXdK51BTZp0IMsyAiszL5WAMuy4+bnWSlpUUGGPSR9KW9ZJ+CNvH1ekPQIsC9wQCNymZmZtTj3YJmZlUFEVEXE9cB0YGy2+DdAJbB9RPQBds2WN3cSjFG5b7LeshHAm0W2yxVxW0ZEv7xbz4j4YzMz5LxVkKcXqYDMz3BtwfH7RMS2efscShrCeDtpyKX/lpmZWZvhP0pmZq1AUn9JP5M0OpvooYukg4DRwOPZZn1IPT5Ls+F655To8N+StEN2HtUkoCdwb+FGEbEIuBm4UtLwLHc/SQdK6l2iLH8AJknaXFIP4Od8+G/RlcBXJe2b9zxtI+l/szwfB64ADgG+CQwknbdmZmbWJrjAMjNrHWuAwcCfgXeBt4EzgRMj4rZsm5OB3YDlpKLrryU69lXAZcASYALwxewcr2KOBGYCj0qqBJ4nnfMUtWzfWD8jTU3/FDAbeJ0Pes6IiBmk88O+SxpquAi4HhiUDau8DfhFRDyYncP1FeAkSZ8tUT4zM7NmUUSp/maamVlbI2kOcGZEFM5GaGZmZi3APVhmZmZmZmYl4gLLzMzMzMysRDxE0MzMzMzMrETcg2VmZmZmZlYiLrDMzMzMzMxKxAWWmZmZmZlZibjAMjMzMzMzKxEXWGZmZmZmZiXy/wE95yDwdcnyJAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -560,9 +584,16 @@ "### Usage in CV" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The example below shows how this looks like in a scikit-learn context using `cross_val_score`:" + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -617,12 +648,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA6GklEQVR4nO3de5yUdd3/8fcbFhDY5XxGDqZoKQnIapn5y9vs5Nm8jcws1Dyf0iRN7U5NU9PbLA+VmmftVjFTszRPlGZaIIKIopCAyknktLAILPv5/XFdq+O4553ZmV1ez8djHjNzHb7Xe+aC3fns93t9xxEhAAAAAEDLdSh0AAAAAABoLyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAC0e7YPtv1X2+/Z3mj7HduTbX+10Nlq2B5pOxpxq9nulFbM1t32T23Psb3e9lLbf7N9TA6PMd/2lblqL6PdA2z/w/Yq22tsv2L7N7ZLm9jOxPR9L02f15yH/TO2+aHtvXL7CgAAbU1JoQMAQD7Z/oWk0yTdLunXkt6TNELSNyX9xfZ2ETGvgBFrLJa0e8bzT0i6S9LJkl6sZbs3Wy+a7pc0TtLFkmZJGiDp/0naV9LvcnSMQ5Scm5yxfbikuyX9Vkn2kLSzpO9K6iVpbQuarzkPr2Us+6GkayVNaUG7AIA2znzRMID2yvZBkv4o6aiIuLWW9QdImhYRi2pZ1zUi1uc9ZB1sj5b0sqT/iogpBcwxStLrkr4REfdlrXO08JdIPt9n2/+QtCoi9qtlXZOy254o6RZJZRFRa2Fme7mkayPiguYlBgC0BwwRBNCefV/Sv2srriQpIh6uKa7S4V5n2r7a9rtKihvZ7mf7tnR4YaXtKbbLM9upbcie7QvSD9w1z2uGmO1q+5l0qN3rtg9p6ovKPl6aabLto2y/aXut7Ttsd7G9m+1/pcum2B6e1dZWtn9u+y3bG2zPsL1vxia90vsltbx/HylQbA+3/X+2V6Tv1WO2d8hYXzOs7gjbt9teJenhdN3Hhgja3jMdiliZvv832i7LWN/L9k22F9l+3/ZC2zdmZf9Y7uzsGef+l2n2Vbavsd25tn2zXsv+Nfkl9ZX0k4zhnHvVtT8AoP2iwALQLtkuUTKE669N2G2SpMGSjlQyrFBKesC+IuksSROU/Nx82vZ2zYx2j6QHJX1dSRF3n+0xzWwr02eVDH07VclQtW9IukbSjZJ+KenbSoYd3pC132RJEyX9TNIBkv4t6SHbY9P1cyStk3S17S/b3qq2g9vuI+lZSTtIOiE9fndJT9jumrX5lZIqJB2WHre29vaQ9ISSAum/lRTL+yrpRapxlaTPSzpDyTk6V8kwwBovSjrc9im2h9R2nAw/kLS1pCOUDCc8TtIlDeyT6RBJq5UMmdw9vb1Y7x4AgHaJa7AAtFd9JXWR9FbmQtuW1DFj0eaM3ozFETEhY9uvStpD0l4R8bd02VOS5ispxo5vRq6bIuLKtK3HJM2W9CMl14S1RKmkgyJiddr2XpKOlfSFiPh7umyIpOtsd4uISttflLSfMl6fpL/a3l7SeZIOi4g1to9VUqg9JmmT7ecl3ZG+lpr37gwlBdXYiFiRHu8fSt6royVdl5H1+Yg4uYHXc5mk57LOxzuSnrQ9OiJmSdpN0nURcU/GfndmPD5X0qeVFJrX2H5TScH884jI7tmqSF9vtZJr87pIOs/2pTWvpz4RMd12laS3I+L5hrYHALRf9GABaO+yr7P5gaRNGbfMD/p/ztp2N0nLMooPRcQ6SX9S0nPSHA9ktFWtpDdrt2a2lWlqTXGVmitpo5JepcxlklTTm7OPkh6if9guqblJelLSB8MgI+L3SiYGOVrS/0naXklP2N0Zbe8j6XFJazLaqZA0LbOt1CP1vRDb3ZT0AN2bletZJedsfLrpS5Im2T4pLQo/IiLeSrfdR9L/SlqhpBCcaXvrrM0fTM9HjT9I6ippdH1ZAQDIRoEFoL16T9IGJcO+Mt0hadf0lm1p1vPBkpbVsV2fZubKbm9ZepyWWpX1fKOkiqyiYWN6XzPMr5+kQfpowblJ0gWShmU2FhHvRcQtEfGddN0tkr6ZMbyxn5IhlNlt/Vd2W/r4+5ytt5Jexuuz2togqVNGe6co6ZH6H0lzbL9h+yM9gRGxOSKejIizIqJcyVDCPkoK7Uy1nRcpN+cGALAFYYgggHYpIqps/1PSl5V8AK9ZvlTpB/xktOBHd8t6vljJlOTZBirpDamxQVL2hAi964g2QB+djnxAepxCWCHpHUkHN2WniNjkZPr7oyR9UtKMtK2HJP20ll0qspto4BCr0m0u0Md7FSVpUZpjlZJr5U6zvbOSa8/usj0zImbXkf2vtmekuTNln+ea54U6NwCANooeLADt2dWSPmP7yGbu/4KkAbb/X82CdPjafvro0Lu3JX0qY5sOkr5YR5uHZG13kKR/NTNfSz2ppAdrbURMzb6lGctqmaRCkkal90sz2tpJ0iu1tDWnKaHSYZjPS9qhtly1TasfETOVXBfXQWnxZPtjxXE6ScfW+ngv2kHp+ajxdUnrlXzvV2Nt1Ie9gwCALRQ9WADarYh40PbVkm61/V9KpgRfrmQCjC+nm9X5ZbMR8Zjt5yTdY/scJT1PZym5NueKjE0fkHSy7emS/iPpe5J61NHs92xvVPLB/XuStpN0ePNeYYs9rmTiisdtXy7pFSW5x0raKiJ+pGRWwIds3yzpOUmV6frzlFwDVVNoXqVkpsKnbF+jpGdsoKQvSHo2vY6rKX6oZEKLaiUzHVZIGq6kuD0vIl63/ayS936Wkh6vY5XMeFhTsD5m+zUl5/0tJcXkKUp6F3+bdbwyJTM63qikUPyxkgk0GpzgIsNrkvaz/aiSf1dzIiK79w4A0M5RYAFo1yLiDNt/l3SSkim0yyS9K+mfkvaNiL800MTBSiZIuFpJ78S/JO0dEXMztrlQyZCyi5X0YlyrpFipbaa8b0r6RbrtW5ImRMT05ry2loqIsP11JbPtfV9JAbNCSeF0TbrZPEk3Kbl26UQlxeVCSTdLujwiqtK2ltv+rJKpzX+h5DuoFispwGY2I9uzac/hhUqum+soaYGkR/Vh79M/lUwxP1LSZknTJX0tIt5O1/9cyft9uZLz866SqdM/HxHZvYb/q2Qa+98r6QX7Xfq+NMUkJbMlPiKpm5Lrz6Y0sQ0AQBvnJnyRPQCgmWxPVDIxRFlE1NlrhtZnOySdGhHXFjoLAKDt4xosAAAAAMgRCiwAAAAAyBGGCAIAAABAjtCDBQAAAAA5QoEFAAAAADlCgQWgVdkea/t52+ts35K1LmzvlT7ubPsC22PzkCEvbdueYntyjtvcK53lrqn79bf9K9v/sr3R9vwWZJiYub/t3Wxf0Nz26jlO2D4l1+02cMyiOWdZbXS3/Vb6nozOWvcL2+ttz7S9b8vSAgByjQILQGu7WNJQSUekj+vSWdJPlHypba7lq+2TJP0ox20211BJEyQtUfK9Vrm0m5L3L9d2l3RfHtqtTzGds0znSepUx7qrJR0iaZOS71wDABQRvmgYQGvbXtKfIuKPhQ6SaxExu9AZMsyMiIGSZPtKSf/d2gFsW1KXiHi/MdtHxPN5jlTbMYvpnEmSbG8n6TRJZ0n6dfb6iFggaUG63TW2O0fExlaOCQCoAz1YAFpbZ0nrGrFdRXp/SzpMKmyPlCTbW9n+eTqEaoPtGdlDpWwfaHtaOhRxpe0XbH+hobbrY3sn24/aXpG2+6rtkzPWf2S4WUbb2beJGdvsaftvtittv2f7RttljXh/6hUR1S1tozZp9mvSxzWvZ0r6/ALby21/3va/Jb0v6bB0uNu1tuekr/NN29fZ7pHV9keGCNa8n7a/ZXuu7TW2/2J76ybkbTPnLMPVkm6S9FoD29V8YXXnHB4bANBC9GABKBoR4Yyne0t6SskwwkfSZYvT+8n6cJjaPEnfkPSQ7fKIeMn2tuk2v5Q0SdJWksZL6tOItuvzsKRXJX1b0gZJO0jqUc/2u2c9/5akUyTNlSTbe0h6QtIflfQw9ZV0maTe6XNFxBRJme+L0uuhpkTExEZkbrGIuFXSrenTRyT9r6Qf6MPXtyZj826SbpP0c0mvS1qULuuoZNjbu5KGpY/vk/SVBg7/GUlD0uN1VXJOb5DU2GuP2tQ5s72fpM9KOlLSmHpfGQCgKFFgAWhtvdS4Hqx/p/fzMoeO2f6ipP0k7RURf0sX/9X29ko+tB8maZykioiYlNHenxtquz62+0naRtJBEfFyuvjJ+vbJyj1e0rGSLoyIZ9PFl0l6LiImZGz3jqQnbY+OiFl1NF0laXNjcudaRLxbM+FFHe9dV0lnRsSDWctPrHlgu0TSm5KetT08IhbWc8gekvaLiJXpvoMk/cJ214hYX1/WtnbObHdW0nv1PxGxMhlhWa/K9L6nPuzNAgAUGEMEAbSKdJjY0Uo+DE5rQVP7KJm44R+2S2puSj44l6fbvCypp+3bbH/ZdvcWhU+skPSWpN/YnmB7QGN3tN1f0h+U9HxclC7rpqS35N6s1/GskskLxtfVXkRsFxHHNP+l5FVI+kv2QttH2p5ue62S11dTsGzfQHv/rimuUjXXTA1tRJa2ds7OVDKs8reNjDldUrWkk233cCMqMgBA/lFgAci79PqmtZJ+J+maiHioBc31kzRIyQfazNsFSoaeKSLmSDpI0ieU9Fwtt313+qG5WdJrmr6spLi7WdIS28/YHlfffukH8HslbZT07Yiomb67t5Jhc9dnvY4NSmaPG9bcrAW2MnvCBduHSLpd0j+V9DB+VskseFIyfLM+q7Ke17Td0H5t6pyl/zbPU/LvuMx2L0ml6eqy2v5IEBFvSDpZ0g8lrZb0hextAACtjyGCAFrDIkl7KrlW6iTbd0XEC81sa4WkdyQdXN9GEfGIpEds91QypPBqJZMzfLOZx1VEvCbpUNudlLyey9NjbF3PpBJXStpV0mcjYnXG8lVKensu0EeHL9ZY1NycBVbb9z8dJumFiDipZoE/nHAkv2HazjkbqqSgqu07uZ5T0kO7T+bCtEfuckkPSvqVpBdbcHwAQI5QYAHIu7RH41nbz0s6RkmvQkMFVl09FU8qmfBgbfrhuaFjr5Z0d/qBvmYCg0b3gtTR5iZJT9m+StLdSq4rW5G9ne0jJZ0u6ZvZ1+ZExLr0/dghIi5qTo4C2iglszk2cgr2rkp6eTIdkfNU9WgD52yupP/KWjZW0i8kHa3ai6c9lFyj9sOImJfjPACAZqLAAtBqIqLK9nLVP4tbzbYbbb8p6Ru2Zym5NmWmpMclPSbpcduXS3olbW+spK0i4ke2j1dSTD2qpFdhlJJelNvra7u+7xKyvbOSno17JP1HyXCxsyXNiIjaPqhvq2S2u78o+c6iz2asnhcR7yoZ2vWk7WolPRcVkoYr6XE7LyJeryPLXEl/a+iaHts13321vaRuGc//lh5ftm9VMmHIyPraylJT2J5u+ylJa9JhmXV5XNJ1ts9TUljvK+mLTThes7SlcxYRayVNydqn5uG/65g8o+b/0bLa2gQAFAYFFoDWFsqawroeJyj5gPyEpC6StomI+ba/LulcSd9X8uF2haSXlH4/k5JC7EBJVymZmn2xpBsl/U99bUuaX0+WJZKWKrlOZoiS4WJPK/nAXpthSnrIvpbeMh0l6daIeNb2/5N0oaQ7lFzfs0BJYbi0niwl6bYNua+O5/+lDz/Md1PTP6A/I+kKJT09l0r6u6S96tn+t0quhztdyXvyuJLpz/P9xcJt8Zw1Rc3/o9qGZQIACsQfXrsLAPlne56kP0fEqYXOAsn2AiXTgt9W6CxomrSn9jeSujZyqCYAoBXQgwWgtb0t6fO2h0haUs9EA8gz20OVzH73+0JnQePZ7qBkuONXJS2nuAKKx7Rp0zp36NDhxI4dOx4VET3V+BEbaBvC9urNmzffUl1d/evx48fXemkBBRaA1naVpLuUzAR4m6SJBU2TSj+01vnVFRFR1YpxWkVEvKNk6FybtCWes9RVSoZbblLdwx0BFEBJScmNPXr02GPIkCHrOnfu/B5fT9e+RIQ2btzYadGiRaeuWbNmF0nfrW07vgcLQKuKiAeVfJfVaCXTXReLm/Xx79b64JZ+lxeKy5Z6zv5X0s6S+kTELwodBsBHfH7EiBGru3Tpsoniqv2xrS5dumwaMWLEakmfr2s7erAAtLp0SNMrhc6R5QJJ19azvq1+L1V7doG2wHMWEW9JeqvQOQDUqmOHDh2Y4KCdS89xnRMXUWDVol+/fjFy5MhCxwDQisaPH9/gNuXl5a2QBI3FOQOQb9OmTVseEf0LnQNtCwVWLUaOHKmpU6cWOgYAAAAKKJ1pFWgSCiwAAAAgj372+41jKjfk/3N3ty6qOvfwzjPyfZxsv/71r/tcffXVg+bMmTM7H9u3NUxyAQAAAORRaxRXTTlOt27dxtXcSkpKdikpKdklc1lTj3viiSeuaEqx1NTtW9OcOXM62x4/b968Ts1tgx4sAAAAYAtSWVk5vebxhAkTRlRVVfn++++fX9u2GzZscJcuXZi4ownowQIAAAAgSdptt912OProo4fts88+25aWlo678MILB86bN6/TnnvuOap3795jysrKxo4fP36HZ555plvNPr/61a/6Dh8+fHRmG8cee+zWX/nKV7bt3r37uGHDho2+8847ezV3++rqap1zzjmDBg4cuHPPnj3HHnPMMcN233337c8888xav8tx/fr1Pvzww0f06dNnTGlp6bgRI0aMvvnmm3vXrH/00UdLx48fv0PPnj3HDhs2bPRPfvKTgdXV1ZKk8vLyHSVp9OjRo7t16zZu0qRJg5v6HlJgAQAAAPjAvffe2++0005btmbNmuk/+tGPllVXV/uEE05YtnDhwpcXL148Y+edd66cMGHCths2bKjzy74mT57c96yzzlqyZs2a6d/73veWnXjiiSMrKirqrD3q2/7666/ve+ONNw78wx/+8MayZctmDB48eOO///3v0rrauu666/q+9NJL3WfPnj1r7dq105988sk5Y8aMWS9J06ZN2+rQQw8ddcYZZyx97733XnrooYfm3nTTTQOuv/76vpI0derU2ZI0a9asWZWVldOvuOKKxU19/yiwAAAAAHzga1/72soDDzywokOHDiorK6seNWrUxiOOOGJ1WVlZdWlpaVx11VXvLF68uPOsWbO61NXG/vvvv/JLX/rSuo4dO+qMM85Yvnbt2o7N3f7uu+/ue+SRR767xx57rO/SpUtcdNFFSwcMGLCprrY6d+4clZWVHV566aWumzZt0nbbbbdp/Pjx70vSL3/5ywH77rvvym9/+9urSkpKNG7cuPe/973vLbv77rv7tuQ9y8Q1WAAAAAA+MGLEiA2ZzxcvXlxy0kknbf3888+XVVRUlNgOSVqyZEmdtcTgwYM/KIB69OhRLUlr1qyp88t569t+yZIlnUaMGLGxZn2HDh00ePDgjR9vJXHiiSe+t3Tp0k5nnXXWsAULFnTZfffdK6666qq3R48evWHhwoWdn3/++R5lZWW9araPCA8aNKjO9pqKHiwAAAAAH+jQ4aMlwhlnnDF06dKlnZ5//vnX1q5dO33hwoUzpaQwaY08gwYN2rRgwYLONc+rq6u1ePHiznVt36lTJ11yySVLZs2a9eqbb775cteuXasnTpw4UpK23nrrjYcddtjyioqKl2pua9eunT537txXpI+/9uagwAIAAABQp4qKio5du3at7t+/f9Xq1as7nHrqqVu35vEPP/zw9+68887+zz33XNcNGzb4wgsvHLhs2bI6p1F/6KGHyp555pluGzZscPfu3au7d+9e3bFjx5Ck008/fdnDDz/c5+677+65YcMGb9q0SdOmTdvqkUceKZWSnrQOHTpo9uzZWzU3LwUWAAAAkEfduqiqLR/nZz/72Tvvvfdep759+47daaeddvrc5z63tmPHOkf75dzJJ5/83lFHHbXs4IMPHjVgwIAxb7/9ducxY8as69KlS3Vt2y9evLjTxIkTt+ndu/fYQYMGjXnrrbc633TTTQskadddd31/8uTJb1xzzTUDBw0atHO/fv3GTpw4cZuagq20tDQmTZr0zlFHHfWJsrKysWefffagpuZ1BNPaZysvL4+pU6cWOgYAAAAKyPa0iChv7PYzZsyYP2bMmOX5zARp8+bNGjx48M4XXXTR2yeccMKKQmSYMWNGvzFjxoysbR09WAAAAACK2g033NC7srLSFRUVHc4888wh77//fodDDz10daFz1YYCCwAAAEBR++1vfztg4MCBY4YMGbLzM8880+MPf/jDG/37999c6Fy1YZp2AAAAAEVt2rRpcwqdobHowQIAAACAHKHAAgAAAIAcocACAAAAgByhwAIAAACAHKHAAgAAAIAcYRZBAAAAII9WXXXWmFi/Lu+fu921e1WvM6+cke/jNMV2222309lnn73o2GOPXVnoLK2FAgsAAADIo9YorppynG7duo2rebxx40ZLUufOnaNmWWVl5fSmHnvOnDmdP/nJT3567ty5M7fddttNNcvnzp37SlPbai2HHnroyJKSkrjnnnsW5LJdCiwAAABgC5JZQE2YMGFEVVWV77///vkFjNSucA0WAAAAAEnSG2+80fmrX/3qJ/r16zemf//+Ox9++OEjVq5c2UGSqqurdeqppw4dMGDAzt27dx83dOjQT19yySUDJKm8vHxHSRo9evTobt26jZs0adJgSRo6dOinr7/++j6S9Kc//amspKRk/I033th72LBho8vKysbuu+++n6hpX5JmzpzZZdddd92htLR03A477LDjT3/60wG2x9eV949//GPZpz71qR1LS0vH9e7de8znPve57WvWVVRUdDjuuOO2Hjp06Kd79uw5ds899xw1a9asLpJ0/vnnD3zwwQf73H///X27des2rlu3buOqqqpy8h5SYAEAAABQZWWlv/jFL27/yU9+8v358+fPnD179iuLFi3qdNxxxw2XpD/+8Y897r333r7PPffcq+vWrZv+r3/969W99tqrQpKmTp06W5JmzZo1q7KycvoVV1yxuLZjbN68WY8//niPWbNmzZ49e/asV155pdtll102QJI2bdqkAw88cNROO+1UuWTJkpceeOCBubfffnv/+jIfd9xx25xwwglL16xZM33RokUzzz333A+Oe8QRR4x44403tnr++edfXbp06Yzy8vJ1BxxwwHYbNmzwxRdfvPSggw5aceihh75XWVk5vbKycnpJSW4G91FgAQAAANA999zTKyJ09dVXLyotLY3+/ftvvvjiixc9+OCDfaqqqtS5c+fYuHGjX3rppa6VlZUeOnRo1R577LG+qce5+uqr3+nZs2f1sGHDqr761a+uevHFF7tL0lNPPVW6aNGiztdee+3bpaWlseOOO2486aSTltbXVqdOnWLevHld3n777ZKuXbvG/vvvXyFJixcvLnn44Yf73HDDDQuHDRtWtdVWW8WVV165aPny5Z2mTJnSvXnvUONQYAEAAADQf/7zn86LFy/uXFZWNrbmtu+++25vW2+99Van/fffv+K8885759JLLx08YMCAsXvssceov//9792acoyOHTtqyJAhH4zF6969e/W6des6StLChQs79enTp6q0tPSDCTe22WabDfW1N3ny5Lnz5s3basyYMTttu+22O1100UUDJOn111/vLEm77LLLjjWvpVevXmOrqqo8f/78zk3J3FRMcgEAAABAI0aM2Dhy5MgN9c38d9ZZZy0/66yzlldUVHSYNGnSkAkTJmy7ePHilzt0aHm/zfDhwzetXLmyZO3ata4pshoqhnbffff1jzzyyH+qq6v117/+tfTggw/efuzYsevHjx+/XpLmzJkzK7Ogy5SLzLW2m5dWAQAAALQpEyZMWL1p0yafc845g1auXNmhurpab775Zqfbb7+9lyQ9/fTT3R599NHS9evXu2vXrtVlZWWba4qUwYMHb+rQoYNmz569VXOPv/fee68dPHjwxtNOO23ryspKv/baa52vv/76gXVt//777/uaa67pu3jx4pIOHTqob9++VbajY8eOMXTo0KoDDjhgxTHHHDP8zTff7CRJy5cv73j77bf3Wr16dQdJGjhw4KYFCxZ02bx5c3Mj14oCCwAAAMgjd+2em+np8nycsrKy6ieffHLOq6++2nWHHXYY3aNHj3F777339tOnT+8mSRUVFR3PPPPMYf369Rvbu3fvsU899VSPO++8c54klZaWxqRJk9456qijPlFWVjb27LPPHtTU43fq1EkPPPDA3JkzZ3br37//2IMOOmi7CRMmvNepU6eoa5/Jkyf33nHHHXfq1q3buEMOOWTUpEmTFu23335rJemuu+5aMGrUqPf32muvHbp37z5u9OjRO9133329bUuSTjrppHcrKys79O7de2xZWdnYXM0i6Ig6826xysvLY+rUqYWOAQAAgAKyPS0iyhu7/YwZM+aPGTNmeT4zbWmuuOKKftddd92g+fPnzyp0lkwzZszoN2bMmJG1raMHCwAAAEBReOyxx0pfeeWVLtXV1XrhhRe6/upXvxp0yCGHrCh0rqZgkgsAAAAARWH+/PmdJ06cuM2qVatKevfuXbX//vuvvOSSS2r9Tq1iRYEFAAAAoCgcf/zxK44//vg21WOVjQIrR376++ZdFPfjw1vnFDQ3n1T8GcmXKPZ8UvFnJF/L8HOm5dZc9f1m7dfjzKtzmqMuxZ4PAIoB12ABAAAAuVFdXV3tQodAfqXnuLqu9e2+wLLd0fYVtt+1XWH7ftv9Cp0LAAAA7YvtJevXr2/290ChbVi/fv1WtpfUtb7dF1iSzpF0kKTPSNo6XXZH4eIAAACgPaqqqrpw/vz5ndetW9eVnqz2p7q62uvWres6f/78zlVVVRfWtd2WcA3WcZIuioj/SJLtH0qaa3tERCwobDQAAAC0F7vssstjL7744inz5s37SUQM0pbRmbElqba9pKqq6sJddtnlsbo2atcFlu1ekoZLmlazLCLm2V4jaYykBRnbHqekGNPw4cNbNygAAADahfSDd50fvtH+tfequiy9X521fJWkHpkLIuKGiCiPiPL+/fu3RjYAAAAA7Ux7L7Aq0vueWct7SVrTulEAAAAAtHftusCKiFWSFkrapWaZ7U8o6b2aWaBYAAAAANqpdl1gpW6QdLbtbWz3kHS5pMciYn5hYwEAAABobxwRhc6QV7Y7KimqJkrqIulxScdFxPK69ikvL4+pU6e2TkAAAAAUJdvTIqK80DnQtrTrWQQlKSI2SzorvQEAAABA3mwJQwQBAAAAoFVQYAEAAABAjlBgAQAAAECOUGABAAAAQI5QYAEAAABAjlBgAQAAAECOUGABAAAAQI5QYAEAAABAjlBgAQAAAECOUGABAAAAQI5QYAEAAABAjlBgAQAAAECOUGABAAAAQI6UNGYj25b0TUnlksoy10XEcXnIBQAAAABtTmN7sH4t6VpJwyR1yroBAAAAANTIHixJh0naLSLm5TMMAAAAALRlje3BqpS0MJ9BAAAAAKCta2yB9XNJ/5NeiwUAAAAAqEVjhwieJmmEpFNtL8tcERHb5zwVAAAAALRBjS2wLs5rCgAAAABoBxpVYEXEbfkOAgAAAABtXWN7sGR7V0lHK5mq/S1JN0fEv/MVDAAAAADamkZNcmH7YEl/l9RT0nRJPST9zfYh+YsGAAAAAG1LY3uwfiLp0Ij4c80C21+TdJmkB/IRDAAAAADamsZO0z5S0qNZyx5TMrMgAAAAAECNL7AWSNona9kXxZcPAwAAAMAHGjtE8KeSHrQ9WdKbSnq0DpX03TzlAgAAAIA2p1E9WBFxv5Ieq0pJ5ZLWS/pSREzOYzYAAAAAaFMaPU17RDwn6bk8ZgEAAACANq3OAsv2ZyLihfTx5+raLi28AAAAAGCLV18P1hOSytLHz9axTUjqmNNEAAAAANBG1VlgRURZxuPGzjYIAAAAAFusRhVOto+sY/kRuY0DAAAAAG1XY3umrqtj+TW5CgIAAAAAbV1jCyx/bIE9UlJVTtMAAAAAQBtW7zTttjcpncjC9sas1R0l/TpfwQAAAACgrWnoe7D2UdJ79WdJX8tYXi1pSUS8ka9gAAAAANDW1FtgRcTfJMn2thGxuHUiAQAAAEDb1FAPliQpIhbb7itpV0n9lXFNVkTcnqdsAAAAANCmNKrAsr2PpPslbZTUS9Kq9P5NSRRYAAAAAKDGzyJ4maSLIqK/pLXp/U8l/SZvyQAAAACgjWlsgTVK0tXp45rhgZdL+n6O8wAAAABAm9XYAqtSUpf08Xu2h0vqLKl3XlIBAAAAQBvU2ALrOUkHp4//IukhSU9I+mceMgEAAABAm9SoSS4kfVsfFmNnSfqBpDJJV+UjFAAAAAC0RQ0WWLZLJF2ppKhSRLwv6ZI850KO/fT3Vc3e98eHN7YOb5nmZiRfotjzScWfkXwtw8+ZliNfy6y56vvN3rfHmVfnLEd9mpuRfIlizwdIjRgiGBFVkr4paUP+4wAAAABA29XYa7AeknRoPoPkg+1v2n7G9hrbzf/TKgAAAAA0QmP77DtJutP2CZLmS6quWRERx+UhV66slHS9pK6SbihwFgAAAADtXGMLrE2Sfp8+7pjeil5EPCZJtvcqbBIAAAAAW4JGFVgRcVS+gxSa7eMkHSdJw4cPL3AaAAAAAG1RY6/Bku2etr9l+4fp80G2h+QvWuuKiBsiojwiyvv371/oOAAAAADaoEYVWLbHS5or6RxJP04X7yzpmjzlAgAAAIA2p7E9WFdL+mFE7CypZja+5yR9Nh+hAAAAAKAtauwkFztJujV9HJIUEWttd89HqFyx3VHJDIid0+dbpas2REQULBgAAACAdsmNqTNsz5H05YhYYHtFRPSxvZ2kByNip7ynbCbbEyXdUsuqbSJifl37lZeXx9SpU/MVCwAAAG2A7WkRUV7oHGhbGjtE8DZJ/2f785KcXpN1k6Qb85YsByLi1ohwLbf5hc4GAAAAoP1p7BDByyV1l/RnSaWSnpb0SzHJBQAAAAB8oLHfg7VZ0nmSzrPdLyKW5zcWAAAAALQ9jZ2m/dGax5nFle1H8hEKAAAAANqixl6D9bk6ljNNOwAAAACk6h0iaPtbNdvZPlySM1aPkrQyX8EAAAAAoK1p6BqsS9L7LpJ+lrG8WtISSafmIxQAAAAAtEX1FlgRsY0k2X4oIg5snUgAAAAA0DY16hosiisAAAAAaFidPVi2fxURp6WPb6hru4g4Lh/BAAAAAKCtqW+IYKc6HgMAAAAAalFngRURJ2Y8Pqp14gAAAABA29XY78ECAAAAADSAAgsAAAAAcoQCCwAAAAByhAILAAAAAHKk3gLL9kO297Xt1goEAAAAAG1VQz1Y70m6V9J82z+2PaQVMgEAAABAm1RvgZVOzz5E0s8lfV1JofWg7a/RqwUAAAAAH9XgNVgRsSYirouIcZL2lLRcSa/Wm7bPz3dAAAAAAGgrmjTJRUS8EBHHKCm0Nku6MC+pAAAAAKANanSBZbvE9mG2H5c0VdLbko7MWzIAAAAAaGNKGtrA9vaSjpX0nXT72ySdGhGv5TkbAAAAALQp9RZYtv8m6fOS/iHpB5Lui4gNrREMAAAAANqahnqwpks6ISJebY0wAAAAANCWNXQN1mWSPl3bCtvfsD0g95EAAAAAoG1qqMD6oaRRdaz7hKSzcxsHAAAAANquhgqsfSXdVMe6WyTtn9s4AAAAANB2NVRgDYqIpbWtSJcPyn0kAAAAAGibGiqwNtoeXNuKdPmm3EcCAAAAgLapoQLrH5JOrWPdyZKeyW0cAAAAAGi7Gpqm/RJJz9juL+n3kt6RNFTS4ZKOUPIdWQAAAAAANVBgRcRU2wdKuk7SMZJCkiXNlXRgRLyY/4gAAAAA0DY01IOliHhc0va2R0nqL+ndiHgj78kAAAAAoI1psMCqkRZVFFYAAAAAUIeGJrkAAAAAADQSBRYAAAAA5AgFFgAAAADkCAUWAAAAAOQIBRYAAAAA5AgFFgAAAADkCAUWAAAAAOQIBRYAAAAA5AgFFgAAAADkCAUWAAAAAOQIBRYAAAAA5EhJoQO0FyPPeaRZ+82/bL8cJ6ndp2/7dLP3ffm7L+cwSd2am5F8iWLPJ0nXnfBUs/Y7+Td75zhJ7cjXMm+f80yz9936sj1zmKRuzc3YWvmefGrbZu33xb3n5ThJ7Yo93y1vLGr2vkeNGpLDJHVrbkbyJYo9HyDRgwUAAAAAOUOBBQAAAAA5UpQFlu1Ohc4AAAAAAE3VagWW7UG2H7a92vbrto+xHbZH2r7V9l3p/QpJv0r3OdH2nHSf523vmdHeBbafyDrGFNvnp4/3sl1l+7u2F9hekbZf2lqvGQAAAMCWpTV7sO6StFHSMEmfl3Rk1vrDJP1FUn9JP7B9uKSfSvqOpL6SbpT0qO0RTThmR0kHSNpZ0qckbS/pqto2tH2c7am2p7777rtNOAQAAAAAJFqlwLK9taS9JU2KiDURsUxJ8ZTp2Yi4JyI2R0SlpKMk/TYiXoiIqoj4naSZkr7VxMOfHRGrI2KppP+R9B3bH3vdEXFDRJRHRHn//v2b/BoBAAAAoLV6sIam9wszli3I2mZ+1vNhkt7MWjYvXd4UmceZL6mLpH5NbAMAAAAAGtRaBdY76f3wjGXDs7apznr+lqSRWcs+kS6XpApJ3bPW1/YlB5lDCkdK2iBped1RAQAAAKB5WqXAioi3JU2RdJntMtv9JZ3fwG63Sjre9m62S2wfJWmspLvT9dMk7WJ7fLr+FEnb1NLOpbZ72B4g6QJJd0REdjEHAAAAAC3miGidA9mDlUxUsaekpZJ+Iel6Jb1Ol0qqiojvZe1ziqTTJA2UNEfSDyNiSsb6SyXV7PObtO0nIuJi23tJekLSMZIuktRD0sOSTo6IivqylpeXx9SpU1vwagEAANDW2Z4WEeWFzoG2pdUKrI8d2P6KpAcldY08hKgpsCKipKn7UmABAACAAgvN0eTio7lsj1VyndXLSobyXSzpnnwUVwAAAABQCK35PVi9Jf1B0lpJzyqZcv30Vjw+AAAAAORVq/VgRcTTkrZrxeNNUSu+PgAAAABozR4sAAAAAGjXKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRyiwAAAAACBHKLAAAAAAIEcosAAAAAAgRxwRhc5QdGy/K2lBDpvsJ2l5DtvLtWLPJxV/RvK1XLFnJF/LFHs+qfgzkq/lij0j+VomH/lGRET/HLeJdo4CqxXYnhoR5YXOUZdizycVf0bytVyxZyRfyxR7Pqn4M5Kv5Yo9I/laptjzYcvBEEEAAAAAyBEKLAAAAADIEQqs1nFDoQM0oNjzScWfkXwtV+wZydcyxZ5PKv6M5Gu5Ys9IvpYp9nzYQnANFgAAAADkCD1YAAAAAJAjFFgAAAAAkCMUWAAAAACQIxRYeWS7o+0rbL9ru8L2/bb7FTpXDdvftP2M7TW2qwqdJ5vty22/kuZbZPtG230KnSuT7Utsv5lmXGZ7su3hhc6VzXYH28/ZDttbFzqPJNm+1fYm22szbicVOldtbO9j+/k043Lb1xc6kySl/z8y37/16TnepdDZatgeZPue9OfgSttP2R5T6Fw1bPe1fZvtJbZX277bdu8C5qn357Ltr6bnfb3tWba/XCz5bA+1/aDtBem/w2+3ZrZGZtw3/Te4PP33+IztPYso3562X7S9Iv33+KLtrxdLvqztTkzP8/mtmS89dn3v4V5prsyfjc+1dkZs2Siw8uscSQdJ+oykmg+1dxQuzseslHS9pO8XOEddNkv6tqS+ksYoeQ9vLWSgWtwhaWxE9JA0UtJCSf9X0ES1O0NSZaFD1OK2iCjNuBVF4ZLJ9l6SJku6Usm/xa0l3VTASB+IiJ0y3z9JV0maHREvFjpbhusl9ZG0vaSBkqZK+pNtFzTVh26XVCpplKRtlJzjQv6crvPnsu1PSPqDpEsl9UzvH7A9shjySaqW9FdJ35L0ditmylZfxt6SrpG0naT+ku6W9Bfbw1otXf355kg6RMm/w17pNnfa/lQrZZMa8dnA9ghJP5D0citlytZQxs1Zv1s+13rRAKmk0AHaueMkXRQR/5Ek2z+UNNf2iIhYUNhoUkQ8Jn3wAbLoRMS5GU/ftf1LSfcWKk9tIuK1jKdW8gFjhwLFqZXt7SWdJOlQSdMLHKctulTSbyJicsayYipgJEm2SyQdrSRvMdlO0rURsVKSbP9O0iQlHyCXFzKY7e6SviZpXERUpMt+JmmK7eERsbC1MzXwc/m7kqZFxJ3p87tsn5Auv7DQ+SJisaTr0vWbWyNPbRrIeFfWol/b/omkXSW9lfdwajDfsprHtjso+Z3SQcn/o1cLnS/D7ySdJ+nEVoj0McX++QWgBytPbPeSNFzStJplETFP0holvTFoui9KmlHoENlsf8v2aklrJZ0u6YLCJvpQ+gv6ZklnSVpV2DS1OjQdCvO6k+G0pYUOlCn9AL6bpJJ0qM5y21Nslxc6Wy0OVtKrcXuBc2S7Qsl57m97KyV/eHo2IgpaXKWccatR83txbKunadgYZfxOSb0ofqc0m+1PS+qnwvXE1Mr2KkkbJD0j6QUlPYNFwfbxktZFxD2FzlKPjrbfSof+PlJMw5KxZaDAyp+y9H511vJVknq0bpS2z/ahkk5QUsAUlYi4OyJ6ShqspLgqpl/Up0taEhEPFDpILa6R9EklH24OkfQFSTcWNNHH9Vbyc/JwSRMlDVHyQefP6R9Risnxku6JiFWFDpLlH5I6Slqm5I8QX5d0bEETpSJiraQpki6w3ct2f0k1PefF+HO6TPxOyRnbAyTdL+nKiHij0HkyRUQvJUNXD5H0Z0lFcZ20k2uMz1cyKqJYvabkDyTbKPkdM1PSU7aHFDIUtiwUWPlTkd73zFreS0kvFhrJ9mFKPngfWGTXlnxERCxRkvNPLoLJOGxvp2SM/CmFzlKbiJgWEUsjojoiXlFyndh/2+5S6GwZav4f3xIRMyNio5IheJ0kFc2YftvbKunh/U2hs2RKe1CfkPS6kp+F3SRdIukZ2wMLmS3Dt5X0FLwq6V+SHkyXF0MPW7YK8TslJ9IP208r+YPJjwocp1YRsSEi/qjkj0/fK3CcGjdJujgi3il0kLpExJKImBERVRGxKiJ+JGmFkuHAQKugwMqT9K/ICyV9MJtXeoFyDyV/TUEj2D5K0m8lHRARTxc6TyOUSOqupKej0D6v5CLuWbaX68Prhma6OGfrq07vi2XyA0XEaknzJUX2qlqWFdLxkmZExAuFDpKlj5K/Il8TEWsiYmNE3KTkd8/uhY2WiIh3ImJCRAyOiG0kvSnpfUnPFzhabWYo43dKapyKcOh0MUsnBXlG0l8i4pSIKKb/y7UpUTIJSzH4kqSfpcOll0vaQ9KPbD9T4FwNqVYR/W5B+0eBlV83SDrb9ja2e0i6XNJjETG/sLESTqaR30pS5/T5VumtKH4I2T5NycxtX4mIfxQ6TzYnU5+fkg4zkZPpz69T8oH8tfr2bSX3StpWyVCJsZL2TZd/WUVwnU46zW6v9PEoSf8r6aGIeL+gwT7ueklH2d4xnUhikpIej6KY9td2ZyXDF4uq90qS0uusXpd0ku3utktsH61kqFtR/KHJ9g62+6T/n3eVdLWkywo11LKBn8u3Syq3fbjtTrYPlzRe0m1Fku+D50o+zHZKn7fqhFr1ZbT9SUnPSvp9RJzVmrkame9Q259O/69sZftYSXtLeqwY8kkapuSav7HpbaqS33v/3Vr5Gspoe2/b26X/p0ttX6BkBtNWew8BRQS3PN2UXHdwpZKhJhVKptftV+hcGfkm6sO/xGfeRhY6W5ovJG1Sct3GB7dC58rI10HJ2PhlktZJekfSXZK2LXS2OvKOTN/TrQudJc0zRcmwjXVKeg2uktSj0LlqyWlJF0laouR6l6eVTM1f8Gxpvm8qGSJWWugsdeT7lKQ/pT8HVyuZpOGgQufKyHespMVKvsbgDUmnFzhPvT+XJX1V0iuS1qf3Xy6yfLWtu6BYMkq6JX28Nut2RJHkOyX9d7g2/fn4T0mHFcv7V8u2UySd35r5GvEeniFpQfq7ZZmkRyXt2toZuW3ZN0cUe884AAAAALQNDBEEAAAAgByhwAIAAACAHKHAAgAAAIAcocACAAAAgByhwAIAAACAHKHAAgAAAIAcocACgC2Y7QtsP9GC/c+1/XALM8y1PbElbQAAUCwosACgldj+hO37bC+xvdb2W7YfsN250NmaKyJ+FhEHFDoHAADFggILAFrPnyUtlrSDpDJJu0t6TJILGQoAAOQOBRYAtALbfZUUVr+JiNWReDsifhMRG9Jtxtj+m+3ltlfa/ovtbTPauNX2HbZvtr3K9ju2D7c91va/bVfYftr2kIx95tv+H9vPpr1mU23vWk/ObravtP2m7RW2H7W9XT3bf2SIYXq8c20/mR5vlu3PZazvZPsq28vSnryza2lzzzTvCtvzbP/AttN1d9j+q+0O6fO9bK+x/enGngsAAPKJAgsAWkFEvCfpFUk32f6O7R1riobMzSRdIGmopJGS1kq6M2ub/5Z0v6Q+kn4q6UZJF0k6RNLAtI0Ls/Y5QdLp6T6TJf3Zdo86ot4o6ZOSPitpkKQXJP3JdqcmvNyjJZ0mqaekxyXdlrHuHEn7S/qcpG3S1zmiZqXtHZX09F0hqb+k/SSdIunIjNeytaTzbQ+U9HtJp0fEy03IBwBA3lBgAUDr2UvSFEnfl/SSpKW2f1xTaEXEzIh4OiI2RMRqJYXSZ213y2jjqYh4JCKqJd0uqbukO9LesEolBVR51nF/FxHTImKjpMslrVdS5HyE7X6SviXppIhYmm5/oaTBkj7ThNf524h4JSI2S7pJ0na2e6brviPp8oiYGxHrJZ2lpCiscZKk+yLiwYjYHBGvSbo23U8RsU7SYel+j0t6NCJuaUI2AADyqqTQAQBgSxERyyWdK+nctGj6hpIeo3ck3ZwOB7xCSTFTpg8Lj/6SFqSPF2e0V5nWZh8sk1SZ7ptpfsY+YXuhkl6gbNuk9zOzOtc6SRrWqBeZlVHSuvS+TNLq9LiZedbZXpaVYW/bX89Y1kHSWxn7vGL7aUkHSDq4CbkAAMg7erAAoAAiojIibpU0U9LYdPFvJFVI2jkiekjaI13e0kkwRtY8SHvLhkt6u5btaoq4URHRK+PWLSJ+38IMNd7JytNdSQGZmeHmrOP3iIidMvb5tpIhjJOVDLnkdxkAoGjwSwkAWoHt3rYvtT06neihxPahkkZLeibdrIeSHp9V6XC9i3J0+KNt75JeRzVJUjdJj2RvFBHLJN0t6XrbQ9PcvWwfYrs0R1nukDTJ9ra2u0r6uT76u+h6Sd+0fUDG+7Sj7S+keT4l6TpJR0j6rqR+Sq5bAwCgKFBgAUDr2ChpgKQ/SFoh6V1J50s6LSLuS7c5Q9KektYoKbr+lKNj3yDpV5JWSpogab/0Gq/aHCtpjqQptiskvazkmqeoY/umulTJ1PTPS3pT0kJ92HOmiJil5Pqw7ysZarhM0q2S+qfDKu+T9IuIeCK9husbkk63/aUc5QMAoEUckavfmQCAYmN7vqTzIyJ7NkIAAJAH9GABAAAAQI5QYAEAAABAjjBEEAAAAAByhB4sAAAAAMgRCiwAAAAAyBEKLAAAAADIEQosAAAAAMgRCiwAAAAAyJH/D13iViTcQs3kAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -835,9 +866,9 @@ ], "metadata": { "kernelspec": { - "display_name": "mlxtend", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "mlxtend" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -849,7 +880,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.7" } }, "nbformat": 4, From 7c2deddeb2c05dc2ead9dae13c5f0a8e0db1d5db Mon Sep 17 00:00:00 2001 From: rasbt Date: Tue, 24 May 2022 09:59:43 -0500 Subject: [PATCH 28/30] merge ex 1 and 4 --- .../evaluate/GroupTimeSeriesSplit.ipynb | 141 ++++-------------- 1 file changed, 31 insertions(+), 110 deletions(-) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index da4dc3c98..c9662e71e 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -311,6 +311,37 @@ "print_split_info(X, y, groups, **cv_args)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Please note that if we specify the number of groups for both the training and the test set, the split size is determined automatically, and the number of splits naturally changes with the groups sizes. For example, increasing the number of training groups will naturally result in a lower number of splits as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_args = {\"test_size\": 1, \"train_size\": 4}\n", + "\n", + "plot_splits(X, y, groups, **cv_args)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -632,116 +663,6 @@ "print_cv_info(cv, X, y, groups, clf, scores)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example 4 -- Expanding the window size" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we try to expand training dataset set to 4 groups (in comparison with example 1), then number of splits will be adjusted accordingly." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train indices: [0 1 2 3 4 5 6 7 8 9]\n", - "Test indices: [10 11]\n", - "Train length: 10\n", - "Test length: 2\n", - "Train groups: [0 1 1 1 1 2 2 2 3 3]\n", - "Test groups: [4 4]\n", - "Train group size: 4\n", - "Test group size: 1\n", - "Train group months: ['2021-01' '2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03'\n", - " '2021-03' '2021-04' '2021-04']\n", - "Test group months: ['2021-05' '2021-05']\n", - "\n", - "Train indices: [ 1 2 3 4 5 6 7 8 9 10 11]\n", - "Test indices: [12 13 14 15]\n", - "Train length: 11\n", - "Test length: 4\n", - "Train groups: [1 1 1 1 2 2 2 3 3 4 4]\n", - "Test groups: [5 5 5 5]\n", - "Train group size: 4\n", - "Test group size: 1\n", - "Train group months: ['2021-02' '2021-02' '2021-02' '2021-02' '2021-03' '2021-03' '2021-03'\n", - " '2021-04' '2021-04' '2021-05' '2021-05']\n", - "Test group months: ['2021-06' '2021-06' '2021-06' '2021-06']\n", - "\n" - ] - } - ], - "source": [ - "cv_args = {\"test_size\": 1, \"train_size\": 4}\n", - "\n", - "plot_splits(X, y, groups, **cv_args)\n", - "print_split_info(X, y, groups, **cv_args)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Usage in CV" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Split number: 1\n", - "Train true target: [1 0 1 0 1 0 0 1 1 1]\n", - "Train predicted target: [1 1 1 1 1 1 1 1 1 1]\n", - "Test true target: [0 1]\n", - "Test predicted target: [1 1]\n", - "Accuracy: 0.5\n", - "\n", - "Split number: 2\n", - "Train true target: [0 1 0 1 0 0 1 1 1 0 1]\n", - "Train predicted target: [1 1 1 1 1 1 1 1 1 1 1]\n", - "Test true target: [1 0 0 0]\n", - "Test predicted target: [1 1 1 1]\n", - "Accuracy: 0.25\n", - "\n" - ] - } - ], - "source": [ - "cv = GroupTimeSeriesSplit(**cv_args)\n", - "clf = DummyClassifier(strategy=\"most_frequent\")\n", - "\n", - "scores = cross_val_score(clf, X, y, groups=groups, scoring=\"accuracy\", cv=cv)\n", - "print_cv_info(cv, X, y, groups, clf, scores)" - ] - }, { "cell_type": "markdown", "metadata": {}, From fb2a2f0550c836a6f44562a322d0e8fe7fda6469 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Wed, 25 May 2022 09:27:08 +0300 Subject: [PATCH 29/30] Fix typo --- docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb index c9662e71e..291466add 100644 --- a/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb +++ b/docs/sources/user_guide/evaluate/GroupTimeSeriesSplit.ipynb @@ -408,7 +408,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's take a look at an example where we don't specify the number of training groups. Here, we will split the dataset with test size (2 goups) and a specified number of splits (3 groups), which is sufficient for calculating the training size automatically." + "Now let's take a look at an example where we don't specify the number of training groups. Here, we will split the dataset with test size (2 groups) and a specified number of splits (3 groups), which is sufficient for calculating the training size automatically." ] }, { @@ -801,7 +801,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.5" } }, "nbformat": 4, From fc178568fc9a77c2f924466f5d91cb40fcc67545 Mon Sep 17 00:00:00 2001 From: Dmitry Labazkin Date: Wed, 25 May 2022 09:50:22 +0300 Subject: [PATCH 30/30] Add entry for GroupTimeSeriesSplit --- docs/sources/CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/sources/CHANGELOG.md b/docs/sources/CHANGELOG.md index c07ce73a5..a91b0d775 100755 --- a/docs/sources/CHANGELOG.md +++ b/docs/sources/CHANGELOG.md @@ -26,6 +26,7 @@ The CHANGELOG for the current development version is available at - The `mlxtend.evaluate.bootstrap_point632_score` now supports `fit_params`. ([#861](https://github.com/rasbt/mlxtend/pull/861)) - The `mlxtend/plotting/decision_regions.py` function now has a `contourf_kwargs` for matplotlib to change the look of the decision boundaries if desired. ([#881](https://github.com/rasbt/mlxtend/pull/881) via [[pbloem](https://github.com/pbloem)]) - Add a `norm_colormap` parameter to `mlxtend.plotting.plot_confusion_matrix`, to allow normalizing the colormap, e.g., using `matplotlib.colors.LogNorm()` ([#895](https://github.com/rasbt/mlxtend/pull/895)) +- Add new `GroupTimeSeriesSplit` class for evaluation in time series tasks with support of custom groups and additional parameters in comparison with scikit-learn's `TimeSeriesSplit`. ([#915](https://github.com/rasbt/mlxtend/pull/915) via [Dmitry Labazkin](https://github.com/labdmitriy)) ##### Changes