From cd8ecb90e86051d09cfcfa0b4b70477d33c7257c Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Tue, 22 Jun 2021 00:34:32 -0700 Subject: [PATCH 01/14] WIP: having exhaustive feature selector take a custom iterator as input --- .../exhaustive_feature_selector.py | 168 +++++++++--------- .../tests/test_exhaustive_feature_selector.py | 122 +++++++------ 2 files changed, 145 insertions(+), 145 deletions(-) diff --git a/mlxtend/feature_selection/exhaustive_feature_selector.py b/mlxtend/feature_selection/exhaustive_feature_selector.py index 4e5de529b..a3c0f4f2e 100644 --- a/mlxtend/feature_selection/exhaustive_feature_selector.py +++ b/mlxtend/feature_selection/exhaustive_feature_selector.py @@ -25,7 +25,7 @@ from joblib import Parallel, delayed -def _calc_score(selector, X, y, indices, groups=None, **fit_params): +def _calc_score(selector, X, y, name, indices, groups=None, **fit_params): if selector.cv: scores = cross_val_score(selector.est_, X[:, indices], y, @@ -38,7 +38,7 @@ def _calc_score(selector, X, y, indices, groups=None, **fit_params): else: selector.est_.fit(X[:, indices], y, **fit_params) scores = np.array([selector.scorer(selector.est_, X[:, indices], y)]) - return indices, scores + return name, indices, scores def _get_featurenames(subsets_dict, feature_idx, custom_feature_names, X): @@ -75,10 +75,6 @@ class ExhaustiveFeatureSelector(BaseEstimator, MetaEstimatorMixin): Parameters ---------- estimator : scikit-learn classifier or regressor - min_features : int (default: 1) - Minumum number of features to select - max_features : int (default: 1) - Maximum number of features to select print_progress : bool (default: True) Prints progress as the number of epochs to stderr. @@ -149,14 +145,12 @@ class ExhaustiveFeatureSelector(BaseEstimator, MetaEstimatorMixin): http://rasbt.github.io/mlxtend/user_guide/feature_selection/ExhaustiveFeatureSelector/ """ - def __init__(self, estimator, min_features=1, max_features=1, + def __init__(self, estimator, print_progress=True, scoring='accuracy', cv=5, n_jobs=1, pre_dispatch='2*n_jobs', clone_estimator=True): self.estimator = estimator - self.min_features = min_features - self.max_features = max_features self.pre_dispatch = pre_dispatch self.scoring = scoring self.scorer = get_scorer(scoring) @@ -176,7 +170,7 @@ def __init__(self, estimator, min_features=1, max_features=1, # don't mess with this unless testing self._TESTING_INTERRUPT_MODE = False - def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): + def fit(self, X, y, candidates, custom_feature_names=None, groups=None, **fit_params): """Perform feature selection and learn model from training data. Parameters @@ -188,10 +182,10 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): argument for X. y : array-like, shape = [n_samples] Target values. - custom_feature_names : None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) + candidates : iterator + A generator of (indices, label) where indices + are columns of X and label is a name for the + given model. groups : array-like, with shape (n_samples,), optional Group labels for the samples used while splitting the dataset into train/test set. Passed to the fit method of the cross-validator. @@ -217,83 +211,26 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): else: X_ = X - if (custom_feature_names is not None - and len(custom_feature_names) != X.shape[1]): - raise ValueError('If custom_feature_names is not None, ' - 'the number of elements in custom_feature_names ' - 'must equal the number of columns in X.') - - if (not isinstance(self.max_features, int) or - (self.max_features > X.shape[1] or self.max_features < 1)): - raise AttributeError('max_features must be' - ' smaller than %d and larger than 0' % - (X.shape[1] + 1)) - - if (not isinstance(self.min_features, int) or - (self.min_features > X.shape[1] or self.min_features < 1)): - raise AttributeError('min_features must be' - ' smaller than %d and larger than 0' - % (X.shape[1] + 1)) - - if self.max_features < self.min_features: - raise AttributeError('min_features must be <= max_features') - - candidates = chain.from_iterable( - combinations(range(X_.shape[1]), r=i) for i in - range(self.min_features, self.max_features + 1) - ) - - def ncr(n, r): - """Return the number of combinations of length r from n items. - - Parameters - ---------- - n : {integer} - Total number of items - r : {integer} - Number of items to select from n - - Returns - ------- - Number of combinations, integer - - """ - - r = min(r, n-r) - if r == 0: - return 1 - numer = reduce(op.mul, range(n, n-r, -1)) - denom = reduce(op.mul, range(1, r+1)) - return numer//denom - - all_comb = np.sum([ncr(n=X_.shape[1], r=i) - for i in range(self.min_features, - self.max_features + 1)]) - - n_jobs = min(self.n_jobs, all_comb) + n_jobs = self.n_jobs parallel = Parallel(n_jobs=n_jobs, pre_dispatch=self.pre_dispatch) work = enumerate(parallel(delayed(_calc_score) - (self, X_, y, c, groups=groups, **fit_params) - for c in candidates)) + (self, X_, y, n, c, groups=groups, **fit_params) + for c, n in candidates)) try: - for iteration, (c, cv_scores) in work: + for iteration, (n, c, cv_scores) in work: self.subsets_[iteration] = {'feature_idx': c, 'cv_scores': cv_scores, - 'avg_score': np.mean(cv_scores)} + 'avg_score': np.mean(cv_scores), + 'feature_names': n} if self.print_progress: - sys.stderr.write('\rFeatures: %d/%d' % ( - iteration + 1, all_comb)) + sys.stderr.write('\rFeatures: %d' % ( + iteration + 1)) sys.stderr.flush() if self._TESTING_INTERRUPT_MODE: - self.subsets_, self.best_feature_names_ = \ - _get_featurenames(self.subsets_, - self.best_idx_, - custom_feature_names, - X) raise KeyboardInterrupt except KeyboardInterrupt as e: @@ -305,17 +242,13 @@ def ncr(n, r): if self.subsets_[c]['avg_score'] > max_score: max_score = self.subsets_[c]['avg_score'] best_subset = c + score = max_score idx = self.subsets_[best_subset]['feature_idx'] - + self.best_feature_names_ = self.subsets_[best_subset]['feature_names'] self.best_idx_ = idx self.best_score_ = score self.fitted = True - self.subsets_, self.best_feature_names_ = \ - _get_featurenames(self.subsets_, - self.best_idx_, - custom_feature_names, - X) return self def transform(self, X): @@ -341,7 +274,7 @@ def transform(self, X): X_ = X return X_[:, self.best_idx_] - def fit_transform(self, X, y, groups=None, **fit_params): + def fit_transform(self, X, y, candidates, groups=None, **fit_params): """Fit to training data and return the best selected features from X. Parameters @@ -364,7 +297,7 @@ def fit_transform(self, X, y, groups=None, **fit_params): Feature subset of X, shape={n_samples, k_features} """ - self.fit(X, y, groups=groups, **fit_params) + self.fit(X, y, candidates, groups=groups, **fit_params) return self.transform(X) def get_metric_dict(self, confidence_interval=0.95): @@ -411,3 +344,64 @@ def _check_fitted(self): if not self.fitted: raise AttributeError('ExhaustiveFeatureSelector has not been' ' fitted, yet.') + +def min_max_candidates(nfeatures, + min_features=1, + max_features=1, + custom_feature_names=None): + """ + Parameters + ---------- + nfeatures: int + Number of columns in X. + min_features : int (default: 1) + Minumum number of features to select + max_features : int (default: 1) + Maximum number of features to select + custom_feature_names : None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + Returns + ------- + candidates : iterator + A generator of (indices, label) where indices + are columns of X and label is a name for the + given model. The iterator cycles through + all combinations of columns of nfeature total + of size ranging between min_features and max_features. + Models are labeled with a tuple of the feature names. + The names of the columns default to strings of integers + from range(nfeatures). + + """ + if (custom_feature_names is not None + and len(custom_feature_names) != nfeatures): + raise ValueError('If custom_feature_names is not None, ' + 'the number of elements in custom_feature_names ' + 'must equal the number of columns in X.') + if custom_feature_names is None: + custom_feature_names = ['%d' % i for i in range(nfeatures)] + + if (not isinstance(max_features, int) or + (max_features > nfeatures or max_features < 1)): + raise AttributeError('max_features must be' + ' smaller than %d and larger than 0' % + (nfeatures + 1)) + + if (not isinstance(min_features, int) or + (min_features > nfeatures or min_features < 1)): + raise AttributeError('min_features must be' + ' smaller than %d and larger than 0' + % (nfeatures + 1)) + + if max_features < min_features: + raise AttributeError('min_features must be <= max_features') + + chain_ = lambda i: ((c, tuple([custom_feature_names[n] for n in c])) for c in combinations(range(nfeatures), r=i)) + + candidates = chain.from_iterable(chain_(i) for i in + range(min_features, max_features + 1)) + + return candidates + diff --git a/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py b/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py index 8927f264a..ab4e39ea8 100644 --- a/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py +++ b/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py @@ -10,6 +10,7 @@ from distutils.version import LooseVersion as Version from numpy.testing import assert_almost_equal from mlxtend.feature_selection import ExhaustiveFeatureSelector as EFS +from mlxtend.feature_selection.exhaustive_feature_selector import min_max_candidates from sklearn.ensemble import RandomForestClassifier from sklearn.neighbors import KNeighborsClassifier from mlxtend.classifier import SoftmaxRegression @@ -46,51 +47,42 @@ def test_minfeatures_1(): iris = load_iris() X = iris.data y = iris.target - knn = KNeighborsClassifier() - efs = EFS(estimator=knn, - min_features=0, - max_features=2) expect = ('min_features must be smaller than 5 and larger than 0') assert_raises(AttributeError, expect, - efs.fit, - X, - y) + min_max_candidates, + X.shape[1], + 0, + 2) def test_maxfeatures_1(): iris = load_iris() X = iris.data y = iris.target - knn = KNeighborsClassifier() - efs = EFS(estimator=knn, - min_features=1, - max_features=0) expect = ('max_features must be smaller than 5 and larger than 0') assert_raises(AttributeError, expect, - efs.fit, - X, - y) + min_max_candidates, + X.shape[1], + 1, + 0) def test_minmaxfeatures_1(): iris = load_iris() X = iris.data y = iris.target - knn = KNeighborsClassifier() - efs = EFS(estimator=knn, - min_features=3, - max_features=2) expect = ('min_features must be <= max_features') assert_raises(AttributeError, expect, - efs.fit, - X, - y) + min_max_candidates, + X.shape[1], + 3, + 2) def test_knn_wo_cv(): @@ -99,12 +91,13 @@ def test_knn_wo_cv(): y = iris.target knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, - min_features=2, - max_features=3, scoring='accuracy', cv=0, print_progress=False) - efs1 = efs1.fit(X, y) + candidates = min_max_candidates(X.shape[1], + min_features=2, + max_features=3) + efs1 = efs1.fit(X, y, candidates) expect = {0: {'feature_idx': (0, 1), 'feature_names': ('0', '1'), 'avg_score': 0.82666666666666666, @@ -154,12 +147,13 @@ def test_knn_cv3(): y = iris.target knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, - min_features=3, - max_features=3, scoring='accuracy', cv=4, print_progress=False) - efs1 = efs1.fit(X, y) + candidates = min_max_candidates(X.shape[1], + min_features=3, + max_features=3) + efs1 = efs1.fit(X, y, candidates) expect = {0: {'avg_score': 0.9391025641025641, 'feature_idx': (0, 1, 2), 'feature_names': ('0', '1', '2'), @@ -202,14 +196,15 @@ def test_knn_cv3_groups(): y = iris.target knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, - min_features=3, - max_features=3, scoring='accuracy', cv=GroupKFold(n_splits=3), print_progress=False) np.random.seed(1630672634) + candidates = min_max_candidates(X.shape[1], + min_features=3, + max_features=3) groups = np.random.randint(0, 6, size=len(y)) - efs1 = efs1.fit(X, y, groups=groups) + efs1 = efs1.fit(X, y, candidates, groups=groups) expect = {0: {'cv_scores': np.array([0.97916667, 0.93877551, 0.9245283]), 'feature_idx': (0, 1, 2), @@ -237,12 +232,14 @@ def test_fit_params(): sample_weight = np.ones(X.shape[0]) forest = RandomForestClassifier(n_estimators=100, random_state=123) efs1 = EFS(forest, - min_features=3, - max_features=3, scoring='accuracy', cv=4, print_progress=False) - efs1 = efs1.fit(X, y, sample_weight=sample_weight) + + candidates = min_max_candidates(X.shape[1], + min_features=3, + max_features=3) + efs1 = efs1.fit(X, y, candidates, sample_weight=sample_weight) expect = {0: {'feature_idx': (0, 1, 2), 'feature_names': ('0', '1', '2'), 'cv_scores': np.array([0.947, 0.868, 0.919, 0.973]), @@ -286,12 +283,13 @@ def test_regression(): X, y = boston.data[:, [1, 2, 6, 8, 12]], boston.target lr = LinearRegression() efs_r = EFS(lr, - min_features=3, - max_features=4, scoring='neg_mean_squared_error', cv=10, print_progress=False) - efs_r = efs_r.fit(X, y) + candidates = min_max_candidates(X.shape[1], + min_features=3, + max_features=4) + efs_r = efs_r.fit(X, y, candidates) assert efs_r.best_idx_ == (0, 2, 4) assert round(efs_r.best_score_, 4) == -40.8777 @@ -358,8 +356,6 @@ def _predict(self, X): expect, EFS, Perceptron, - min_features=2, - max_features=2, clone_estimator=True) @@ -369,14 +365,15 @@ def test_clone_params_pass(): y = iris.target lr = SoftmaxRegression(random_seed=1) efs1 = EFS(lr, - min_features=2, - max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) - efs1 = efs1.fit(X, y) + candidates = min_max_candidates(X.shape[1], + min_features=2, + max_features=2) + efs1 = efs1.fit(X, y, candidates) assert(efs1.best_idx_ == (1, 3)) @@ -386,8 +383,6 @@ def test_transform_not_fitted(): knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, - min_features=2, - max_features=2, scoring='accuracy', cv=0, clone_estimator=False, @@ -409,15 +404,17 @@ def test_fit_transform(): knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, - min_features=2, - max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) - X_t = efs1.fit_transform(X, y) + candidates = min_max_candidates(X.shape[1], + min_features=2, + max_features=2) + + X_t = efs1.fit_transform(X, y, candidates) assert X_t.shape == (150, 2) @@ -425,8 +422,6 @@ def test_get_metric_dict_not_fitted(): knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, - min_features=2, - max_features=2, scoring='accuracy', cv=0, clone_estimator=False, @@ -446,16 +441,19 @@ def test_custom_feature_names(): X = iris.data y = iris.target efs1 = EFS(knn, - min_features=2, - max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) - efs1 = efs1.fit(X, y, custom_feature_names=( + candidates = min_max_candidates(X.shape[1], + min_features=2, + max_features=2, + custom_feature_names=( 'sepal length', 'sepal width', 'petal length', 'petal width')) + + efs1 = efs1.fit(X, y, candidates) assert efs1.best_idx_ == (2, 3), efs1.best_idx_ assert efs1.best_feature_names_ == ('petal length', 'petal width') @@ -467,8 +465,6 @@ def test_check_pandas_dataframe_fit(): X = iris.data y = iris.target efs1 = EFS(knn, - min_features=2, - max_features=2, scoring='accuracy', cv=0, clone_estimator=False, @@ -478,13 +474,20 @@ def test_check_pandas_dataframe_fit(): df = pd.DataFrame(X, columns=['sepal length', 'sepal width', 'petal length', 'petal width']) - sfs1 = efs1.fit(X, y) + candidates = min_max_candidates(X.shape[1], + min_features=2, + max_features=2) + sfs1 = efs1.fit(X, y, candidates) assert efs1.best_idx_ == (2, 3), efs1.best_idx_ assert efs1.best_feature_names_ == ('2', '3') assert efs1.interrupted_ is False sfs1._TESTING_INTERRUPT_MODE = True - sfs1 = sfs1.fit(df, y) + candidates = min_max_candidates(X.shape[1], + min_features=2, + max_features=2, + custom_feature_names=df.columns) + sfs1 = sfs1.fit(df, y, candidates) assert efs1.best_idx_ == (0, 1), efs1.best_idx_ assert efs1.best_feature_names_ == ('sepal length', 'sepal width') assert efs1.interrupted_ is True @@ -496,16 +499,19 @@ def test_check_pandas_dataframe_transform(): X = iris.data y = iris.target efs1 = EFS(knn, - min_features=2, - max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) + df = pd.DataFrame(X, columns=['sepal length', 'sepal width', 'petal length', 'petal width']) - efs1 = efs1.fit(df, y) + candidates = min_max_candidates(X.shape[1], + min_features=2, + max_features=2, + custom_feature_names=df.columns) + efs1 = efs1.fit(df, y, candidates) assert efs1.best_idx_ == (2, 3) assert (150, 2) == efs1.transform(df).shape From 425348a8b055bc6f1ae0c6b5a747653b4b94da28 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Mon, 4 Oct 2021 20:53:50 -0700 Subject: [PATCH 02/14] WIP: generic feature selector added; includes both exhaustive and sequential as special cases; allows for categorical variables --- mlxtend/feature_selection/generic_selector.py | 986 ++++++++++++++++++ .../tests/test_generic_selector.py | 161 +++ 2 files changed, 1147 insertions(+) create mode 100644 mlxtend/feature_selection/generic_selector.py create mode 100644 mlxtend/feature_selection/tests/test_generic_selector.py diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py new file mode 100644 index 000000000..5fd1f60a6 --- /dev/null +++ b/mlxtend/feature_selection/generic_selector.py @@ -0,0 +1,986 @@ +# Sebastian Raschka 2014-2020 +# mlxtend Machine Learning Library Extensions +# +# Algorithm for sequential feature selection. +# Author: Sebastian Raschka +# +# License: BSD 3 clause + +# Modified by Jonathan Taylor 2021 +# +# Derives from sequential_feature_selector +# but allows custom model search + +import types +import sys +from functools import partial +from copy import deepcopy +from itertools import combinations, chain + +import numpy as np +import scipy as sp + +from sklearn.metrics import get_scorer +from sklearn.base import (clone, MetaEstimatorMixin) +from sklearn.utils import check_random_state +from sklearn.model_selection import cross_val_score +from joblib import Parallel, delayed + +from ..externals.name_estimators import _name_estimators +from ..utils.base_compostion import _BaseXComposition +from .columns import (_get_column_info, + Column, + _categorical_from_df, + _check_categories) + +def _calc_score(selector, + X, + y, + state, + groups=None, + **fit_params): + + X_state = selector.build_submodel(X, state) + + if selector.cv: + scores = cross_val_score(selector.est_, + X_state, + y, + groups=groups, + cv=selector.cv, + scoring=selector.scorer, + n_jobs=1, + pre_dispatch=selector.pre_dispatch, + fit_params=fit_params) + else: + selector.est_.fit(X_state, + y, + **fit_params) + scores = np.array([selector.scorer(selector.est_, + X_state, + y)]) + return state, scores + + +class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): + + """Feature Selection for Classification and Regression. + + Parameters + ---------- + estimator : scikit-learn classifier or regressor + initial_state : object + Initial state of feature selector. + state_generator : callable + Callable taking single argument `state` and returning + candidates for next batch of scores to be calculated. + build_submodel : callable + Callable taking two arguments `(X, state)` that returns + model matrix represented by `state`. + check_finished : callable + Callable taking three arguments + `(results, best_state, batch_results)` which determines if + the state generator should step. Often will just check + if there is a better score than that at current best state + but can use entire set of results if desired. + verbose : int (default: 0), level of verbosity to use in logging. + If 0, no output, + if 1 number of features in current set, if 2 detailed logging + including timestamp and cv scores at step. + scoring : str, callable, or None (default: None) + If None (default), uses 'accuracy' for sklearn classifiers + and 'r2' for sklearn regressors. + If str, uses a sklearn scoring metric string identifier, for example + {accuracy, f1, precision, recall, roc_auc} for classifiers, + {'mean_absolute_error', 'mean_squared_error'/'neg_mean_squared_error', + 'median_absolute_error', 'r2'} for regressors. + If a callable object or function is provided, it has to be conform with + sklearn's signature ``scorer(estimator, X, y)``; see + http://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html + for more information. + cv : int (default: 5) + Integer or iterable yielding train, test splits. If cv is an integer + and `estimator` is a classifier (or y consists of integer class + labels) stratified k-fold. Otherwise regular k-fold cross-validation + is performed. No cross-validation if cv is None, False, or 0. + n_jobs : int (default: 1) + The number of CPUs to use for evaluating different feature subsets + in parallel. -1 means 'all CPUs'. + pre_dispatch : int, or string (default: '2*n_jobs') + Controls the number of jobs that get dispatched + during parallel execution if `n_jobs > 1` or `n_jobs=-1`. + Reducing this number can be useful to avoid an explosion of + memory consumption when more jobs get dispatched than CPUs can process. + This parameter can be: + None, in which case all the jobs are immediately created and spawned. + Use this for lightweight and fast-running jobs, + to avoid delays due to on-demand spawning of the jobs + An int, giving the exact number of total jobs that are spawned + A string, giving an expression as a function + of n_jobs, as in `2*n_jobs` + clone_estimator : bool (default: True) + Clones estimator if True; works with the original estimator instance + if False. Set to False if the estimator doesn't + implement scikit-learn's set_params and get_params methods. + In addition, it is required to set cv=0, and n_jobs=1. + + Attributes + ---------- + results_ : dict + A dictionary of selected feature subsets during the + selection, where the dictionary keys are + the states of these feature selector. The dictionary + values are dictionaries themselves with the following + keys: 'cv_scores' (list individual cross-validation scores) + 'avg_score' (average cross-validation score) + + Examples + ----------- + For usage examples, please see + TBD + + """ + def __init__(self, + estimator, + initial_state, + state_generator, + build_submodel, + check_finished, + verbose=0, + scoring=None, + cv=5, + n_jobs=1, + pre_dispatch='2*n_jobs', + clone_estimator=True, + fixed_features=None): + + self.estimator = estimator + self.initial_state = initial_state + self.state_generator = state_generator + self.build_submodel = build_submodel + self.check_finished = check_finished + self.pre_dispatch = pre_dispatch + # Want to raise meaningful error message if a + # cross-validation generator is inputted + if isinstance(cv, types.GeneratorType): + err_msg = ('Input cv is a generator object, which is not ' + 'supported. Instead please input an iterable yielding ' + 'train, test splits. This can usually be done by ' + 'passing a cross-validation generator to the ' + 'built-in list function. I.e. cv=list()') + raise TypeError(err_msg) + self.cv = cv + self.n_jobs = n_jobs + self.verbose = verbose + self.clone_estimator = clone_estimator + + if self.clone_estimator: + self.est_ = clone(self.estimator) + else: + self.est_ = self.estimator + self.scoring = scoring + + if scoring is None: + if self.est_._estimator_type == 'classifier': + scoring = 'accuracy' + elif self.est_._estimator_type == 'regressor': + scoring = 'r2' + else: + raise AttributeError('Estimator must ' + 'be a Classifier or Regressor.') + if isinstance(scoring, str): + self.scorer = get_scorer(scoring) + else: + self.scorer = scoring + + self.fitted = False + self.results_ = {} + self.interrupted_ = False + + # don't mess with this unless testing + self._TESTING_INTERRUPT_MODE = False + + @property + def named_estimators(self): + """ + Returns + ------- + List of named estimator tuples, like [('svc', SVC(...))] + """ + return _name_estimators([self.estimator]) + + def get_params(self, deep=True): + # + # Return estimator parameter names for GridSearch support. + # + return self._get_params('named_estimators', deep=deep) + + def set_params(self, **params): + """Set the parameters of this estimator. + Valid parameter keys can be listed with ``get_params()``. + + Returns + ------- + self + """ + self._set_params('estimator', 'named_estimators', **params) + return self + + def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): + """Perform feature selection and learn model from training data. + + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + y : array-like, shape = [n_samples] + Target values. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for y. + custom_feature_names : None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + groups : array-like, with shape (n_samples,), optional + Group labels for the samples used while splitting the dataset into + train/test set. Passed to the fit method of the cross-validator. + fit_params : various, optional + Additional parameters that are being passed to the estimator. + For example, `sample_weights=weights`. + + Returns + ------- + self : object + + """ + + # reset from a potential previous fit run + self.results_ = {} + self.finished = False + self.interrupted_ = False + + # fit initial model + + _state = self.initial_state + + _state, _scores = _calc_score(self, + X, + y, + _state, + groups=groups, + **fit_params) + + # keep a running track of the best state + + self.best_state_ = _state + self.best_score_ = np.nanmean(_scores) + + self.update_results_check({_state: {'cv_scores': _scores, + 'avg_score': np.nanmean(_scores)}}) + + try: + while not self.finished: + + batch_results = self._batch(_state, + X, + y, + groups=groups, + **fit_params) + + _state, _score, self.finished = self.update_results_check(batch_results) + print(_state, self.finished, _score, self.best_score_) + + if self._TESTING_INTERRUPT_MODE: + raise KeyboardInterrupt + + except KeyboardInterrupt: + self.interrupted_ = True + sys.stderr.write('\nSTOPPING EARLY DUE TO KEYBOARD INTERRUPT...') + + self.fitted = True + self.postprocess() + return self + + def _batch(self, + state, + X, + y, + groups=None, + **fit_params): + + results = {} + + candidates = self.state_generator(state) + + if candidates is not None: + + parallel = Parallel(n_jobs=self.n_jobs, + verbose=self.verbose, + pre_dispatch=self.pre_dispatch) + + work = parallel(delayed(_calc_score) + (self, + X, + y, + state, + groups=groups, + **fit_params) + for state in candidates) + + for state, cv_scores in work: + results[state] = {'cv_scores': cv_scores, + 'avg_score': np.nanmean(cv_scores)} + + return results + + def transform(self, X): + """Reduce X to its most important features. + + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + + Returns + ------- + Reduced feature subset of X, shape={n_samples, k_features} + + """ + self._check_fitted() + return self.build_submodel(X, self.best_state_) + + def fit_transform(self, + X, + y, + groups=None, + **fit_params): + """Fit to training data then reduce X to its most important features. + + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + y : array-like, shape = [n_samples] + Target values. + New in v 0.13.0: a pandas Series are now also accepted as + argument for y. + groups : array-like, with shape (n_samples,), optional + Group labels for the samples used while splitting the dataset into + train/test set. Passed to the fit method of the cross-validator. + fit_params : various, optional + Additional parameters that are being passed to the estimator. + For example, `sample_weights=weights`. + + Returns + ------- + Reduced feature subset of X, shape={n_samples, k_features} + + """ + self.fit(X, y, groups=groups, **fit_params) + return self.transform(X) + + def get_metric_dict(self, confidence_interval=0.95): + """Return metric dictionary + + Parameters + ---------- + confidence_interval : float (default: 0.95) + A positive float between 0.0 and 1.0 to compute the confidence + interval bounds of the CV score averages. + + Returns + ---------- + Dictionary with items where each dictionary value is a list + with the number of iterations (number of feature subsets) as + its length. The dictionary keys corresponding to these lists + are as follows: + 'state': tuple of the indices of the feature subset + 'cv_scores': list with individual CV scores + 'avg_score': of CV average scores + 'std_dev': standard deviation of the CV score average + 'std_err': standard error of the CV score average + 'ci_bound': confidence interval bound of the CV score average + + """ + self._check_fitted() + fdict = deepcopy(self.results_) + + def _calc_confidence(ary, confidence=0.95): + std_err = sp.stats.sem(ary) + bound = std_err * sp.stats.t._ppf((1 + confidence) / 2.0, len(ary)) + return bound, std_err + + for k in fdict: + std_dev = np.std(self.results_[k]['cv_scores']) + bound, std_err = self._calc_confidence( + self.results_[k]['cv_scores'], + confidence=confidence_interval) + fdict[k]['ci_bound'] = bound + fdict[k]['std_dev'] = std_dev + fdict[k]['std_err'] = std_err + return fdict + + def _check_fitted(self): + if not self.fitted: + raise AttributeError('{} has not been fitted yet.'.format(self.__class__)) + + def update_results_check(self, + batch_results): + """ + Update `self.results_` with current batch + and return a boolean about whether + we should continue or not. + + Parameters + ---------- + + batch_results : dict + Dictionary of results from a batch fit. + Keys are the state with values + dictionaries having keys + `cv_scores`, `avg_scores`. + + Returns + ------- + + best_state : object + State that had the best `avg_score` + + fitted : bool + If batch_results is empty, fitting + has terminated so return True. + Otherwise False. + + """ + + finished = batch_results == {} + + if not finished: + self.results_.update(batch_results) + + (cur_state, + cur_score, + finished) = self.check_finished(self.results_, + self.best_state_, + batch_results) + if cur_score > self.best_score_: + self.best_state_ = cur_state + self.best_score_ = cur_score + return cur_state, cur_score, finished + else: + return None, None, True + + def postprocess(self): + """ + Find the best model and score from `self.results_`. + """ + + self.best_state_ = None + self.best_score_ = -np.inf + + for state, result in self.results_.items(): + if result['avg_score'] > self.best_score_: + self.best_state_ = state + self.best_score_ = result['avg_score'] + +class MinMaxCandidates(object): + + def __init__(self, + X, + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None): + """ + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + min_features : int (default: 1) + Minumum number of features to select + max_features : int (default: 1) + Maximum number of features to select + fixed_features : column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names : None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features : array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None : no feature will be considered categorical. + - boolean array-like : boolean mask indicating categorical features. + - integer array-like : integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + """ + + if hasattr(X, 'loc'): + X_ = X.values + is_categorical, is_ordinal = _categorical_from_df(X) + self.columns = X.columns + else: + X_ = X + is_categorical = _check_categories(categorical_features, + X_)[0] + if is_categorical is None: + is_categorical = np.zeros(X_.shape[1], np.bool) + is_ordinal = np.zeros_like(is_categorical) + self.columns = np.arange(X.shape[1]) + + nfeatures = X_.shape[0] + + if (not isinstance(max_features, int) or + (max_features > nfeatures or max_features < 1)): + raise AttributeError('max_features must be' + ' smaller than %d and larger than 0' % + (nfeatures + 1)) + + if (not isinstance(min_features, int) or + (min_features > nfeatures or min_features < 1)): + raise AttributeError('min_features must be' + ' smaller than %d and larger than 0' + % (nfeatures + 1)) + + if max_features < min_features: + raise AttributeError('min_features must be <= max_features') + + self.min_features, self.max_features = min_features, max_features + + # make a mapping from the column info to columns in + # implied design matrix + + self.column_info_ = _get_column_info(X, + range(X.shape[1]), + is_categorical, + is_ordinal) + self.column_map_ = {} + idx = 0 + for col in self.columns: + l = self.column_info_[col].columns + self.column_map_[col] = range(idx, idx + + len(l)) + idx += len(l) + if (custom_feature_names is not None + and len(custom_feature_names) != nfeatures): + raise ValueError('If custom_feature_names is not None, ' + 'the number of elements in custom_feature_names ' + 'must equal %d the number of columns in X.' % idx) + if custom_feature_names is not None: + # recompute the Column info using custom_feature_names + for i, col in enumerate(self.columns): + cur_col = self.column_info_[col] + new_name = custom_feature_names[i] + old_name = cur_col.name + self.column_info_[col] = Column(col, + new_name, + col.is_categorical, + col.is_ordinal, + tuple([n.replace(old_name, + new_name) for n in col.columns]), + col.encoder) + + self._have_already_run = False + if fixed_features is not None: + self.fixed_features = set([self.columns[f] for f in fixed_features]) + else: + self.fixed_features = set([]) + + def __call__(self, state): + """ + Produce candidates for fitting. + + Parameters + ---------- + + state : ignored + + Returns + ------- + candidates : iterator + A generator of (indices, label) where indices + are columns of X and label is a name for the + given model. The iterator cycles through + all combinations of columns of nfeature total + of size ranging between min_features and max_features. + If appropriate, restricts combinations to include + a set of fixed features. + Models are labeled with a tuple of the feature names. + The names of the columns default to strings of integers + from range(nfeatures). + + """ + + if not self._have_already_run: + self._have_already_run = True # maybe could be done with a StopIteration on candidates? + def chain_(i): + return (c for c in combinations(self.columns, r=i) + if self.fixed_features.issubset(c)) + + candidates = chain.from_iterable(chain_(i) for i in + range(self.min_features, + self.max_features+1)) + return candidates + + def check_finished(self, + results, + best_state, + batch_results): + """ + Check if we should continue or not. + For exhaustive search we stop because + all models are fit in a single batch. + """ + return best_state, results[best_state]['avg_score'], True + +class StepCandidates(MinMaxCandidates): + + def __init__(self, + X, + direction='forward', + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None): + """ + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + direction : str + One of ['forward', 'backward', 'both'] + min_features : int (default: 1) + Minumum number of features to select + max_features : int (default: 1) + Maximum number of features to select + fixed_features : column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names : None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features : array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None : no feature will be considered categorical. + - boolean array-like : boolean mask indicating categorical features. + - integer array-like : integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + """ + + self.direction = direction + MinMaxCandidates.__init__(self, + X, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + def __call__(self, state): + """ + Produce candidates for fitting. + For stepwise search this depends on the direction. + + If 'forward', all columns not in the current state + are added (maintaining an upper limit on the number of columns + at `self.max_features`). + + If 'backward', all columns not in the current state + are dropped (maintaining a lower limit on the number of columns + at `self.min_features`). + + All candidates include `self.fixed_features` if any. + + Parameters + ---------- + + state : ignored + + Returns + ------- + candidates : iterator + A generator of (indices, label) where indices + are columns of X and label is a name for the + given model. The iterator cycles through + all combinations of columns of nfeature total + of size ranging between min_features and max_features. + If appropriate, restricts combinations to include + a set of fixed features. + Models are labeled with a tuple of the feature names. + The names of the columns default to strings of integers + from range(nfeatures). + + """ + + state = set(state) + if len(state) < self.max_features: # union + forward = (tuple(sorted(state | set([c]))) for c in self.columns if (c not in state and + self.fixed_features.issubset(state | set([c])))) + else: + forward = None + if len(state) > self.min_features: # symmetric difference + backward = (tuple(sorted(state ^ set([c]))) for c in self.columns if (c in state and + self.fixed_features.issubset(state ^ set([c])))) + else: + backward = None + + if self.direction == 'forward': + return forward + elif self.direction == 'backward': + return backward + else: + return chain.from_iterable([forward, backward]) + + def check_finished(self, + results, + best_state, + batch_results): + """ + Check if we should continue or not. + + For stepwise search we stop if we cannot improve + over our current best score. + + """ + batch_best_score = -np.inf + batch_best_state = None + + for state in batch_results: + if batch_results[state]['avg_score'] > batch_best_score: + batch_best_score = batch_results[state]['avg_score'] + batch_best_state = state + + finished = batch_best_score <= results[best_state]['avg_score'] + print(batch_best_state, batch_best_score, results[best_state]['avg_score'], finished, 'BEST!!!!!!!!!!!!!!!!!!!!!!!') + return batch_best_state, batch_best_score, finished + + +def min_max_candidates(X, + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None): + """ + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + min_features : int (default: 1) + Minumum number of features to select + max_features : int (default: 1) + Maximum number of features to select + fixed_features : column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names : None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features : array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None : no feature will be considered categorical. + - boolean array-like : boolean mask indicating categorical features. + - integer array-like : integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + Returns + ------- + + initial_state : tuple + (column_names, feature_idx) + + state_generator : callable + Object that proposes candidates + based on current state. Takes a single + argument `state` + + build_submodel : callable + Candidate generator that enumerate + all valid subsets of columns. + + check_finished : callable + Check whether to stop. Takes two arguments: + `best_result` a dict with keys ['cv_scores', 'avg_score']; + and `state`. + + """ + + min_max = MinMaxCandidates(X, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + # if any categorical features or an intercept + # is included then we must + # create a new design matrix + + def build_submodel(column_info, X, cols): + return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) + build_submodel = partial(build_submodel, min_max.column_info_) + + if min_max.fixed_features: + initial_features = sorted(min_max.fixed_features) + else: + initial_features = range(min_max.min_features) + initial_state = tuple(initial_features) + return initial_state, min_max, build_submodel, min_max.check_finished + +def step_candidates(X, + direction='forward', + min_features=1, + max_features=1, + random_state=0, + fixed_features=None, + initial_features=None, + custom_feature_names=None, + categorical_features=None): + """ + Parameters + ---------- + X : {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + direction : str + One of ['forward', 'backward', 'both'] + min_features : int (default: 1) + Minumum number of features to select + max_features : int (default: 1) + Maximum number of features to select + fixed_features : column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + initial_features : column identifiers, default=None + Subset of features to be used to initialize when direction + is `both`. If None defaults to behavior of `forward`. + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names : None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features : array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None : no feature will be considered categorical. + - boolean array-like : boolean mask indicating categorical features. + - integer array-like : integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + Returns + ------- + + initial_state : tuple + (column_names, feature_idx) + + state_generator : callable + Object that proposes candidates + based on current state. Takes a single + argument `state` + + build_submodel : callable + Candidate generator that enumerate + all valid subsets of columns. + + check_finished : callable + Check whether to stop. Takes two arguments: + `best_result` a dict with keys ['cv_scores', 'avg_score']; + and `state`. + + """ + + step = StepCandidates(X, + direction, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + # if any categorical features or an intercept + # is included then we must + # create a new design matrix + + def build_submodel(column_info, X, cols): + return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) + build_submodel = partial(build_submodel, step.column_info_) + + if direction in ['forward', 'both']: + if step.fixed_features: + forward_features = sorted(step.fixed_features) + else: + forward_features = range(step.min_features) + if direction == 'forward': + initial_features = forward_features + else: + if initial_features is None: + initial_features = forward_features + elif direction == 'backward': + if initial_features is None: + random_state = check_random_state(random_state) + initial_features = sorted(random_state.choice([col for col in step.column_info_], + step.max_features, + replace=False)) + initial_state = tuple(initial_features) + + if len(initial_features) > step.max_features: + raise ValueError('initial_features should be of length <= %d' % step.max_features) + if len(initial_features) < step.min_features: + raise ValueError('initial_features should be of length >= %d' % step.min_features) + if not step.fixed_features.issubset(initial_features): + raise ValueError('initial_features should contain %s' % str(step.fixed_features)) + + return initial_state, step, build_submodel, step.check_finished + + + diff --git a/mlxtend/feature_selection/tests/test_generic_selector.py b/mlxtend/feature_selection/tests/test_generic_selector.py new file mode 100644 index 000000000..df3b76d6b --- /dev/null +++ b/mlxtend/feature_selection/tests/test_generic_selector.py @@ -0,0 +1,161 @@ +from itertools import product + +import numpy as np +from sklearn.linear_model import LinearRegression +from ..generic_selector import (min_max_candidates, + step_candidates, + FeatureSelector) + +have_pandas = True +try: + import pandas as pd +except ImportError: + have_pandas = False + +def test_exhaustive_selector(): + + n, p = 100, 5 + X = np.random.standard_normal((n, p)) + Y = np.random.standard_normal(n) + + (initial_state, + state_generator, + build_submodel, + check_finished) = min_max_candidates(X, + max_features=4, + fixed_features=[2,3]) + + min_max_selector = FeatureSelector(LinearRegression(), + initial_state, + state_generator, + build_submodel, + check_finished) + + min_max_selector.fit(X, Y) + + (initial_state, + state_generator, + build_submodel, + check_finished) = min_max_candidates(X, + max_features=4) + + min_max_selector = FeatureSelector(LinearRegression(), + initial_state, + state_generator, + build_submodel, + check_finished) + + min_max_selector.fit(X, Y) + min_max_selector.transform(X) + min_max_selector.fit_transform(X, Y) + + # test CV + + (initial_state, + state_generator, + build_submodel, + check_finished) = min_max_candidates(X, + max_features=4) + + min_max_selector = FeatureSelector(LinearRegression(), + initial_state, + state_generator, + build_submodel, + check_finished, + cv=3) + # test CV, verbose + + (initial_state, + state_generator, + build_submodel, + check_finished) = min_max_candidates(X, + max_features=4) + + for cv, verbose in product([None, 3], + [0,1,2]): + min_max_selector = FeatureSelector(LinearRegression(), + initial_state, + state_generator, + build_submodel, + check_finished, + cv=3, + verbose=verbose) + + min_max_selector.fit(X, Y) + print(min_max_selector.best_state_) + +def test_exhaustive_categorical(): + + n, p = 100, 5 + X = np.random.standard_normal((n, p)) + X[:,0] = np.random.choice(range(5), (n,), replace=True) + Y = np.random.standard_normal(n) + + categorical_features = [True] + [False]*4 + (initial_state, + state_generator, + build_submodel, + check_finished) = min_max_candidates(X, + max_features=4, + fixed_features=[2,3], + categorical_features=categorical_features) + + min_max_selector = FeatureSelector(LinearRegression(), + initial_state, + state_generator, + build_submodel, + check_finished) + + min_max_selector.fit(X, Y) + + +def test_step_categorical(): + + n, p = 100, 10 + X = np.random.standard_normal((n, p)) + X[:,0] = np.random.choice(range(5), (n,), replace=True) + Y = np.random.standard_normal(n) + + categorical_features = [True] + [False]*9 + (initial_state, + state_generator, + build_submodel, + check_finished) = step_candidates(X, + max_features=4, + fixed_features=[2,3], + categorical_features=categorical_features) + + step_selector = FeatureSelector(LinearRegression(), + initial_state, + state_generator, + build_submodel, + check_finished) + + step_selector.fit(X, Y) + +def test_step_bigger(): + + n, p = 100, 20 + X = np.random.standard_normal((n, p)) + X[:,0] = np.random.choice(range(5), (n,), replace=True) + Y = np.random.standard_normal(n) + + categorical_features = [True] + [False]*(p-1) + + for direction in ['forward', 'backward', 'both']: + (initial_state, + state_generator, + build_submodel, + check_finished) = step_candidates(X, + direction=direction, + max_features=p, + fixed_features=[2,3], + categorical_features=categorical_features) + + step_selector = FeatureSelector(LinearRegression(), + initial_state, + state_generator, + build_submodel, + check_finished) + + step_selector.fit(X, Y) From 4c76af304837c0811e7ebb158963d2d0038e050e Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Mon, 4 Oct 2021 21:37:19 -0700 Subject: [PATCH 03/14] using a named tuple to describe the search strategy --- mlxtend/feature_selection/generic_selector.py | 233 ++++++++++-------- .../tests/test_generic_selector.py | 132 +++++----- 2 files changed, 194 insertions(+), 171 deletions(-) diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py index 5fd1f60a6..18dde5904 100644 --- a/mlxtend/feature_selection/generic_selector.py +++ b/mlxtend/feature_selection/generic_selector.py @@ -12,6 +12,7 @@ # but allows custom model search import types +from typing import NamedTuple, Any, Callable import sys from functools import partial from copy import deepcopy @@ -33,14 +34,39 @@ _categorical_from_df, _check_categories) +class Strategy(NamedTuple): + + """ + initial_state : object + Initial state of feature selector. + state_generator : callable + Callable taking single argument `state` and returning + candidates for next batch of scores to be calculated. + build_submodel : callable + Callable taking two arguments `(X, state)` that returns + model matrix represented by `state`. + check_finished : callable + Callable taking three arguments + `(results, best_state, batch_results)` which determines if + the state generator should step. Often will just check + if there is a better score than that at current best state + but can use entire set of results if desired. + """ + + initial_state : Any + candidate_states : Callable + build_submodel : Callable + check_finished : Callable + def _calc_score(selector, + build_submodel, X, y, state, groups=None, **fit_params): - X_state = selector.build_submodel(X, state) + X_state = build_submodel(X, state) if selector.cv: scores = cross_val_score(selector.est_, @@ -69,20 +95,12 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): Parameters ---------- estimator : scikit-learn classifier or regressor - initial_state : object - Initial state of feature selector. - state_generator : callable - Callable taking single argument `state` and returning - candidates for next batch of scores to be calculated. - build_submodel : callable - Callable taking two arguments `(X, state)` that returns - model matrix represented by `state`. - check_finished : callable - Callable taking three arguments - `(results, best_state, batch_results)` which determines if - the state generator should step. Often will just check - if there is a better score than that at current best state - but can use entire set of results if desired. + strategy : Strategy + Description of search strategy: a named tuple + with fields `initial_state`, + `candidate_states`, `build_submodel`, + `check_finished`. + verbose : int (default: 0), level of verbosity to use in logging. If 0, no output, if 1 number of features in current set, if 2 detailed logging @@ -134,6 +152,11 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): keys: 'cv_scores' (list individual cross-validation scores) 'avg_score' (average cross-validation score) + Notes + ----- + + See `Strategy` for explanation of the fields. + Examples ----------- For usage examples, please see @@ -142,10 +165,7 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): """ def __init__(self, estimator, - initial_state, - state_generator, - build_submodel, - check_finished, + strategy, verbose=0, scoring=None, cv=5, @@ -155,10 +175,7 @@ def __init__(self, fixed_features=None): self.estimator = estimator - self.initial_state = initial_state - self.state_generator = state_generator - self.build_submodel = build_submodel - self.check_finished = check_finished + self.strategy = strategy self.pre_dispatch = pre_dispatch # Want to raise meaningful error message if a # cross-validation generator is inputted @@ -262,14 +279,18 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): self.finished = False self.interrupted_ = False + # unpack the strategy + + initial_state, candidate_states, build_submodel, check_finished = self.strategy + # fit initial model - _state = self.initial_state _state, _scores = _calc_score(self, + build_submodel, X, y, - _state, + initial_state, groups=groups, **fit_params) @@ -278,20 +299,23 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): self.best_state_ = _state self.best_score_ = np.nanmean(_scores) - self.update_results_check({_state: {'cv_scores': _scores, - 'avg_score': np.nanmean(_scores)}}) + self._update_results_check({_state: {'cv_scores': _scores, + 'avg_score': np.nanmean(_scores)}}, + check_finished) try: while not self.finished: batch_results = self._batch(_state, + candidate_states(_state), + build_submodel, X, y, groups=groups, **fit_params) - _state, _score, self.finished = self.update_results_check(batch_results) - print(_state, self.finished, _score, self.best_score_) + _state, _score, self.finished = self._update_results_check(batch_results, + check_finished) if self._TESTING_INTERRUPT_MODE: raise KeyboardInterrupt @@ -304,38 +328,6 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): self.postprocess() return self - def _batch(self, - state, - X, - y, - groups=None, - **fit_params): - - results = {} - - candidates = self.state_generator(state) - - if candidates is not None: - - parallel = Parallel(n_jobs=self.n_jobs, - verbose=self.verbose, - pre_dispatch=self.pre_dispatch) - - work = parallel(delayed(_calc_score) - (self, - X, - y, - state, - groups=groups, - **fit_params) - for state in candidates) - - for state, cv_scores in work: - results[state] = {'cv_scores': cv_scores, - 'avg_score': np.nanmean(cv_scores)} - - return results - def transform(self, X): """Reduce X to its most important features. @@ -353,7 +345,7 @@ def transform(self, X): """ self._check_fitted() - return self.build_submodel(X, self.best_state_) + return self.strategy.build_submodel(X, self.best_state_) def fit_transform(self, X, @@ -429,12 +421,48 @@ def _calc_confidence(ary, confidence=0.95): fdict[k]['std_err'] = std_err return fdict + # private methods + + def _batch(self, + state, + candidates, + build_submodel, + X, + y, + groups=None, + **fit_params): + + results = {} + + if candidates is not None: + + parallel = Parallel(n_jobs=self.n_jobs, + verbose=self.verbose, + pre_dispatch=self.pre_dispatch) + + work = parallel(delayed(_calc_score) + (self, + build_submodel, + X, + y, + state, + groups=groups, + **fit_params) + for state in candidates) + + for state, cv_scores in work: + results[state] = {'cv_scores': cv_scores, + 'avg_score': np.nanmean(cv_scores)} + + return results + def _check_fitted(self): if not self.fitted: raise AttributeError('{} has not been fitted yet.'.format(self.__class__)) - def update_results_check(self, - batch_results): + def _update_results_check(self, + batch_results, + check_finished): """ Update `self.results_` with current batch and return a boolean about whether @@ -449,6 +477,13 @@ def update_results_check(self, dictionaries having keys `cv_scores`, `avg_scores`. + check_finished : callable + Callable taking three arguments + `(results, best_state, batch_results)` which determines if + the state generator should step. Often will just check + if there is a better score than that at current best state + but can use entire set of results if desired. + Returns ------- @@ -469,9 +504,9 @@ def update_results_check(self, (cur_state, cur_score, - finished) = self.check_finished(self.results_, - self.best_state_, - batch_results) + finished) = check_finished(self.results_, + self.best_state_, + batch_results) if cur_score > self.best_score_: self.best_state_ = cur_state self.best_score_ = cur_score @@ -571,7 +606,7 @@ def __init__(self, # implied design matrix self.column_info_ = _get_column_info(X, - range(X.shape[1]), + self.columns, is_categorical, is_ordinal) self.column_map_ = {} @@ -602,11 +637,11 @@ def __init__(self, self._have_already_run = False if fixed_features is not None: - self.fixed_features = set([self.columns[f] for f in fixed_features]) + self.fixed_features = set([self.column_info_[f].idx for f in fixed_features]) else: self.fixed_features = set([]) - def __call__(self, state): + def candidate_states(self, state): """ Produce candidates for fitting. @@ -708,7 +743,7 @@ def __init__(self, custom_feature_names, categorical_features) - def __call__(self, state): + def candidate_states(self, state): """ Produce candidates for fitting. For stepwise search this depends on the direction. @@ -787,12 +822,12 @@ def check_finished(self, return batch_best_state, batch_best_score, finished -def min_max_candidates(X, - min_features=1, - max_features=1, - fixed_features=None, - custom_feature_names=None, - categorical_features=None): +def min_max(X, + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None): """ Parameters ---------- @@ -858,26 +893,28 @@ def min_max_candidates(X, # is included then we must # create a new design matrix - def build_submodel(column_info, X, cols): - return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) - build_submodel = partial(build_submodel, min_max.column_info_) + build_submodel = partial(_build_submodel, min_max.column_info_) if min_max.fixed_features: initial_features = sorted(min_max.fixed_features) else: initial_features = range(min_max.min_features) initial_state = tuple(initial_features) - return initial_state, min_max, build_submodel, min_max.check_finished - -def step_candidates(X, - direction='forward', - min_features=1, - max_features=1, - random_state=0, - fixed_features=None, - initial_features=None, - custom_feature_names=None, - categorical_features=None): + + return Strategy(initial_state, + min_max.candidate_states, + build_submodel, + min_max.check_finished) + +def step(X, + direction='forward', + min_features=1, + max_features=1, + random_state=0, + fixed_features=None, + initial_features=None, + custom_feature_names=None, + categorical_features=None): """ Parameters ---------- @@ -951,9 +988,9 @@ def step_candidates(X, # is included then we must # create a new design matrix - def build_submodel(column_info, X, cols): - return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) - build_submodel = partial(build_submodel, step.column_info_) + build_submodel = partial(_build_submodel, step.column_info_) + + # pick an initial state if direction in ['forward', 'both']: if step.fixed_features: @@ -980,7 +1017,11 @@ def build_submodel(column_info, X, cols): if not step.fixed_features.issubset(initial_features): raise ValueError('initial_features should contain %s' % str(step.fixed_features)) - return initial_state, step, build_submodel, step.check_finished - + return Strategy(initial_state, + step.candidate_states, + build_submodel, + step.check_finished) +def _build_submodel(column_info, X, cols): + return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) diff --git a/mlxtend/feature_selection/tests/test_generic_selector.py b/mlxtend/feature_selection/tests/test_generic_selector.py index df3b76d6b..bb78cc219 100644 --- a/mlxtend/feature_selection/tests/test_generic_selector.py +++ b/mlxtend/feature_selection/tests/test_generic_selector.py @@ -1,10 +1,12 @@ from itertools import product +import pytest + import numpy as np from sklearn.linear_model import LinearRegression -from ..generic_selector import (min_max_candidates, - step_candidates, - FeatureSelector) +from mlxtend.feature_selection.generic_selector import (min_max, + step, + FeatureSelector) have_pandas = True try: @@ -18,32 +20,20 @@ def test_exhaustive_selector(): X = np.random.standard_normal((n, p)) Y = np.random.standard_normal(n) - (initial_state, - state_generator, - build_submodel, - check_finished) = min_max_candidates(X, - max_features=4, - fixed_features=[2,3]) + strategy = min_max(X, + max_features=4, + fixed_features=[2,3]) min_max_selector = FeatureSelector(LinearRegression(), - initial_state, - state_generator, - build_submodel, - check_finished) + strategy) min_max_selector.fit(X, Y) - (initial_state, - state_generator, - build_submodel, - check_finished) = min_max_candidates(X, - max_features=4) + strategy = min_max(X, + max_features=4) min_max_selector = FeatureSelector(LinearRegression(), - initial_state, - state_generator, - build_submodel, - check_finished) + strategy) min_max_selector.fit(X, Y) min_max_selector.transform(X) @@ -51,33 +41,21 @@ def test_exhaustive_selector(): # test CV - (initial_state, - state_generator, - build_submodel, - check_finished) = min_max_candidates(X, - max_features=4) + strategy = min_max(X, + max_features=4) min_max_selector = FeatureSelector(LinearRegression(), - initial_state, - state_generator, - build_submodel, - check_finished, + strategy, cv=3) # test CV, verbose - (initial_state, - state_generator, - build_submodel, - check_finished) = min_max_candidates(X, - max_features=4) + strategy = min_max(X, + max_features=4) for cv, verbose in product([None, 3], [0,1,2]): min_max_selector = FeatureSelector(LinearRegression(), - initial_state, - state_generator, - build_submodel, - check_finished, + strategy, cv=3, verbose=verbose) @@ -92,19 +70,13 @@ def test_exhaustive_categorical(): Y = np.random.standard_normal(n) categorical_features = [True] + [False]*4 - (initial_state, - state_generator, - build_submodel, - check_finished) = min_max_candidates(X, - max_features=4, - fixed_features=[2,3], - categorical_features=categorical_features) + strategy = min_max(X, + max_features=4, + fixed_features=[2,3], + categorical_features=categorical_features) min_max_selector = FeatureSelector(LinearRegression(), - initial_state, - state_generator, - build_submodel, - check_finished) + strategy) min_max_selector.fit(X, Y) @@ -117,20 +89,13 @@ def test_step_categorical(): Y = np.random.standard_normal(n) categorical_features = [True] + [False]*9 - (initial_state, - state_generator, - build_submodel, - check_finished) = step_candidates(X, - max_features=4, - fixed_features=[2,3], - categorical_features=categorical_features) + strategy = step(X, + max_features=4, + fixed_features=[2,3], + categorical_features=categorical_features) step_selector = FeatureSelector(LinearRegression(), - initial_state, - state_generator, - build_submodel, - check_finished) - + strategy) step_selector.fit(X, Y) def test_step_bigger(): @@ -143,19 +108,36 @@ def test_step_bigger(): categorical_features = [True] + [False]*(p-1) for direction in ['forward', 'backward', 'both']: - (initial_state, - state_generator, - build_submodel, - check_finished) = step_candidates(X, - direction=direction, - max_features=p, - fixed_features=[2,3], - categorical_features=categorical_features) + strategy = step(X, + direction=direction, + max_features=p, + fixed_features=[2,3], + categorical_features=categorical_features) step_selector = FeatureSelector(LinearRegression(), - initial_state, - state_generator, - build_submodel, - check_finished) + strategy) step_selector.fit(X, Y) + +@pytest.mark.skipif(not have_pandas, reason='pandas unavailable') +def test_pandas1(): + + n, p = 100, 5 + X = np.random.standard_normal((n, p)) + Y = np.random.standard_normal(n) + D = pd.DataFrame(X, columns=['A', 'B', 'C', 'D', 'E']) + D['A'] = pd.Categorical(np.random.choice(range(5), (n,), replace=True)) + + for direction in ['forward', 'backward', 'both']: + + strategy = step(D, + direction=direction, + max_features=p, + fixed_features=['A','C']) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + cv=3) + + step_selector.fit(D, Y) + From 2b174cb8d278d3509e822254a5ba471a52c7cd60 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Mon, 4 Oct 2021 21:38:16 -0700 Subject: [PATCH 04/14] utilities for extracting columns from a matrix or dataframe --- mlxtend/feature_selection/columns.py | 251 +++++++++++++++++++++++++++ 1 file changed, 251 insertions(+) create mode 100644 mlxtend/feature_selection/columns.py diff --git a/mlxtend/feature_selection/columns.py b/mlxtend/feature_selection/columns.py new file mode 100644 index 000000000..50d767ba0 --- /dev/null +++ b/mlxtend/feature_selection/columns.py @@ -0,0 +1,251 @@ + +from typing import NamedTuple, Any +from copy import copy + +import numpy as np +from sklearn.base import clone +from sklearn.preprocessing import (OneHotEncoder, + OrdinalEncoder) +from sklearn.utils.validation import check_is_fitted +from sklearn.exceptions import NotFittedError + +class Column(NamedTuple): + + """ + A column extractor with a possible + encoder (following `sklearn` fit/transform template). + """ + + idx: Any + name: str + is_categorical: bool = False + is_ordinal: bool = False + columns: tuple = () + encoder: Any = None + + def get_columns(self, X, fit=False): + + """ + Extract associated column from X, + encoding it with `self.encoder` if not None. + + Parameters + ---------- + + X : array-like + X on which model matrix will be evaluated. + If a `pd.DataFrame` or `pd.Series`, variables that are of + categorical dtype will be treated as categorical. + + fit : bool + If True, fit `self.encoder` on corresponding + column. + + Returns + ------- + cols : `np.ndarray` + Evaluated columns -- if an encoder is used, + several columns may be produced. + + names : (str,) + Column names + """ + + cols = _get_column(self.idx, X, twodim=self.encoder is not None) + if fit: + self.fit_encoder(X) + + if self.encoder is not None: + cols = self.encoder.transform(cols) + cols = np.asarray(cols) + + names = self.columns + if hasattr(self.encoder, 'columns_'): + names = ['{0}[{1}]'.format(self.name, c) for c in self.encoder.columns_] + if not names: + names = ['{0}[{1}]'.format(self.name, i) for i in range(cols.shape[1])] + return cols, names + + def fit_encoder(self, X): + + """ + Fit `self.encoder`. + + Parameters + ---------- + X : array-like + X on which encoder will be fit. + + Returns + ------- + None + """ + cols = _get_column(self.idx, X, twodim=self.encoder is not None) + if self.encoder is not None: + try: + check_is_fitted(self.encoder) + except NotFittedError: + self.encoder.fit(cols) + return np.asarray(cols) + +def _get_column(idx, X, twodim=False): + """ + Extract column `idx` from `X`, + optionally making it two-dimensional + as many sklearn encoders assume + two-dimensional input + """ + if isinstance(X, np.ndarray): + col = X[:,idx] + else: # assuming pd.DataFrame + col = X[idx] + if twodim and np.asarray(col).ndim == 1: + return np.asarray(col).reshape((-1,1)) + return np.asarray(col) + +def _get_column_info(X, + columns, + is_categorical, + is_ordinal, + default_encoders={'categorical': OneHotEncoder(drop='first', sparse=False), + 'ordinal': OrdinalEncoder()}): + """ + Compute a dictionary + of `Column` instances for each column + of `X`. Keys are `columns`. + + Categorical and ordinal columns use the + default encoding provided. + + """ + column_info = {} + for i, col in enumerate(columns): + if type(col) == int: + name = f'X{col}' + else: + name = str(col) + Xcol = _get_column(col, X, twodim=True) + if is_categorical[i]: + if is_ordinal[i]: + encoder = clone(default_encoders['ordinal']) + encoder.fit(Xcol) + columns = ['Ord({0})'.format(col)] + else: + encoder = clone(default_encoders['categorical']) + cols = encoder.fit_transform(Xcol) + if hasattr(encoder, 'columns_'): + columns_ = encoder.columns_ + else: + columns_ = range(cols.shape[1]) + columns = ['Cat({0})[{1}]'.format(col, c) for c in range(cols.shape[1])] + + column_info[col] = Column(col, + name, + is_categorical[i], + is_ordinal[i], + tuple(columns), + encoder) + else: + column_info[col] = Column(col, + name, + columns=(name,)) + return column_info + +# extracted from method of BaseHistGradientBoosting from +# https://github.com/scikit-learn/scikit-learn/blob/2beed55847ee70d363bdbfe14ee4401438fba057/sklearn/ensemble/_hist_gradient_boosting/gradient_boosting.py +# max_bins is ignored +def _check_categories(categorical_features, X): + """Check and validate categorical features in X + + Return + ------ + is_categorical : ndarray of shape (n_features,) or None, dtype=bool + Indicates whether a feature is categorical. If no feature is + categorical, this is None. + known_categories : list of size n_features or None + The list contains, for each feature: + - an array of shape (n_categories,) with the unique cat values + - None if the feature is not categorical + None if no feature is categorical. + """ + if categorical_features is None: + return None, None + + categorical_features = np.asarray(categorical_features) + + if categorical_features.size == 0: + return None, None + + if categorical_features.dtype.kind not in ('i', 'b'): + raise ValueError("categorical_features must be an array-like of " + "bools or array-like of ints.") + + n_features = X.shape[1] + + # check for categorical features as indices + if categorical_features.dtype.kind == 'i': + if (np.max(categorical_features) >= n_features + or np.min(categorical_features) < 0): + raise ValueError("categorical_features set as integer " + "indices must be in [0, n_features - 1]") + is_categorical = np.zeros(n_features, dtype=bool) + is_categorical[categorical_features] = True + else: + if categorical_features.shape[0] != n_features: + raise ValueError("categorical_features set as a boolean mask " + "must have shape (n_features,), got: " + f"{categorical_features.shape}") + is_categorical = categorical_features + + if not np.any(is_categorical): + return None, None + + # compute the known categories in the training data. We need to do + # that here instead of in the BinMapper because in case of early + # stopping, the mapper only gets a fraction of the training data. + known_categories = [] + + if hasattr(X, 'loc'): # hacky way to assume pd.DataFrame without importing pd + X_list = [X[c] for c in X.columns] + else: + X_list = X.T + + for f_idx in range(n_features): + if is_categorical[f_idx]: + categories = np.unique(X_list[f_idx]) + missing = [] + for c in categories: + try: + missing.append(np.isnan(c)) + except TypeError: # not a float + missing.append(False) + missing = np.array(missing) + if missing.any(): + categories = categories[~missing] + + else: + categories = None + known_categories.append(categories) + + return is_categorical, known_categories + +def _categorical_from_df(df): + """ + Find categorical and ordinal + variables in a data frame. + """ + is_categorical = [] + is_ordinal = [] + for c in df.columns: + try: + is_categorical.append(df[c].dtype == 'category') + is_ordinal.append(df[c].cat.ordered) + except TypeError: + is_categorical.append(False) + is_ordinal.append(False) + is_categorical = np.array(is_categorical) + is_ordinal = np.array(is_ordinal) + + return is_categorical, is_ordinal + + From bf42afa408edcdedfa748f52faba35646426eb65 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Mon, 4 Oct 2021 21:39:05 -0700 Subject: [PATCH 05/14] reverting exhaustive to previous version --- .../exhaustive_feature_selector.py | 168 +++++++++--------- 1 file changed, 87 insertions(+), 81 deletions(-) diff --git a/mlxtend/feature_selection/exhaustive_feature_selector.py b/mlxtend/feature_selection/exhaustive_feature_selector.py index a3c0f4f2e..4e5de529b 100644 --- a/mlxtend/feature_selection/exhaustive_feature_selector.py +++ b/mlxtend/feature_selection/exhaustive_feature_selector.py @@ -25,7 +25,7 @@ from joblib import Parallel, delayed -def _calc_score(selector, X, y, name, indices, groups=None, **fit_params): +def _calc_score(selector, X, y, indices, groups=None, **fit_params): if selector.cv: scores = cross_val_score(selector.est_, X[:, indices], y, @@ -38,7 +38,7 @@ def _calc_score(selector, X, y, name, indices, groups=None, **fit_params): else: selector.est_.fit(X[:, indices], y, **fit_params) scores = np.array([selector.scorer(selector.est_, X[:, indices], y)]) - return name, indices, scores + return indices, scores def _get_featurenames(subsets_dict, feature_idx, custom_feature_names, X): @@ -75,6 +75,10 @@ class ExhaustiveFeatureSelector(BaseEstimator, MetaEstimatorMixin): Parameters ---------- estimator : scikit-learn classifier or regressor + min_features : int (default: 1) + Minumum number of features to select + max_features : int (default: 1) + Maximum number of features to select print_progress : bool (default: True) Prints progress as the number of epochs to stderr. @@ -145,12 +149,14 @@ class ExhaustiveFeatureSelector(BaseEstimator, MetaEstimatorMixin): http://rasbt.github.io/mlxtend/user_guide/feature_selection/ExhaustiveFeatureSelector/ """ - def __init__(self, estimator, + def __init__(self, estimator, min_features=1, max_features=1, print_progress=True, scoring='accuracy', cv=5, n_jobs=1, pre_dispatch='2*n_jobs', clone_estimator=True): self.estimator = estimator + self.min_features = min_features + self.max_features = max_features self.pre_dispatch = pre_dispatch self.scoring = scoring self.scorer = get_scorer(scoring) @@ -170,7 +176,7 @@ def __init__(self, estimator, # don't mess with this unless testing self._TESTING_INTERRUPT_MODE = False - def fit(self, X, y, candidates, custom_feature_names=None, groups=None, **fit_params): + def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): """Perform feature selection and learn model from training data. Parameters @@ -182,10 +188,10 @@ def fit(self, X, y, candidates, custom_feature_names=None, groups=None, **fit_pa argument for X. y : array-like, shape = [n_samples] Target values. - candidates : iterator - A generator of (indices, label) where indices - are columns of X and label is a name for the - given model. + custom_feature_names : None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) groups : array-like, with shape (n_samples,), optional Group labels for the samples used while splitting the dataset into train/test set. Passed to the fit method of the cross-validator. @@ -211,26 +217,83 @@ def fit(self, X, y, candidates, custom_feature_names=None, groups=None, **fit_pa else: X_ = X - n_jobs = self.n_jobs + if (custom_feature_names is not None + and len(custom_feature_names) != X.shape[1]): + raise ValueError('If custom_feature_names is not None, ' + 'the number of elements in custom_feature_names ' + 'must equal the number of columns in X.') + + if (not isinstance(self.max_features, int) or + (self.max_features > X.shape[1] or self.max_features < 1)): + raise AttributeError('max_features must be' + ' smaller than %d and larger than 0' % + (X.shape[1] + 1)) + + if (not isinstance(self.min_features, int) or + (self.min_features > X.shape[1] or self.min_features < 1)): + raise AttributeError('min_features must be' + ' smaller than %d and larger than 0' + % (X.shape[1] + 1)) + + if self.max_features < self.min_features: + raise AttributeError('min_features must be <= max_features') + + candidates = chain.from_iterable( + combinations(range(X_.shape[1]), r=i) for i in + range(self.min_features, self.max_features + 1) + ) + + def ncr(n, r): + """Return the number of combinations of length r from n items. + + Parameters + ---------- + n : {integer} + Total number of items + r : {integer} + Number of items to select from n + + Returns + ------- + Number of combinations, integer + + """ + + r = min(r, n-r) + if r == 0: + return 1 + numer = reduce(op.mul, range(n, n-r, -1)) + denom = reduce(op.mul, range(1, r+1)) + return numer//denom + + all_comb = np.sum([ncr(n=X_.shape[1], r=i) + for i in range(self.min_features, + self.max_features + 1)]) + + n_jobs = min(self.n_jobs, all_comb) parallel = Parallel(n_jobs=n_jobs, pre_dispatch=self.pre_dispatch) work = enumerate(parallel(delayed(_calc_score) - (self, X_, y, n, c, groups=groups, **fit_params) - for c, n in candidates)) + (self, X_, y, c, groups=groups, **fit_params) + for c in candidates)) try: - for iteration, (n, c, cv_scores) in work: + for iteration, (c, cv_scores) in work: self.subsets_[iteration] = {'feature_idx': c, 'cv_scores': cv_scores, - 'avg_score': np.mean(cv_scores), - 'feature_names': n} + 'avg_score': np.mean(cv_scores)} if self.print_progress: - sys.stderr.write('\rFeatures: %d' % ( - iteration + 1)) + sys.stderr.write('\rFeatures: %d/%d' % ( + iteration + 1, all_comb)) sys.stderr.flush() if self._TESTING_INTERRUPT_MODE: + self.subsets_, self.best_feature_names_ = \ + _get_featurenames(self.subsets_, + self.best_idx_, + custom_feature_names, + X) raise KeyboardInterrupt except KeyboardInterrupt as e: @@ -242,13 +305,17 @@ def fit(self, X, y, candidates, custom_feature_names=None, groups=None, **fit_pa if self.subsets_[c]['avg_score'] > max_score: max_score = self.subsets_[c]['avg_score'] best_subset = c - score = max_score idx = self.subsets_[best_subset]['feature_idx'] - self.best_feature_names_ = self.subsets_[best_subset]['feature_names'] + self.best_idx_ = idx self.best_score_ = score self.fitted = True + self.subsets_, self.best_feature_names_ = \ + _get_featurenames(self.subsets_, + self.best_idx_, + custom_feature_names, + X) return self def transform(self, X): @@ -274,7 +341,7 @@ def transform(self, X): X_ = X return X_[:, self.best_idx_] - def fit_transform(self, X, y, candidates, groups=None, **fit_params): + def fit_transform(self, X, y, groups=None, **fit_params): """Fit to training data and return the best selected features from X. Parameters @@ -297,7 +364,7 @@ def fit_transform(self, X, y, candidates, groups=None, **fit_params): Feature subset of X, shape={n_samples, k_features} """ - self.fit(X, y, candidates, groups=groups, **fit_params) + self.fit(X, y, groups=groups, **fit_params) return self.transform(X) def get_metric_dict(self, confidence_interval=0.95): @@ -344,64 +411,3 @@ def _check_fitted(self): if not self.fitted: raise AttributeError('ExhaustiveFeatureSelector has not been' ' fitted, yet.') - -def min_max_candidates(nfeatures, - min_features=1, - max_features=1, - custom_feature_names=None): - """ - Parameters - ---------- - nfeatures: int - Number of columns in X. - min_features : int (default: 1) - Minumum number of features to select - max_features : int (default: 1) - Maximum number of features to select - custom_feature_names : None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) - Returns - ------- - candidates : iterator - A generator of (indices, label) where indices - are columns of X and label is a name for the - given model. The iterator cycles through - all combinations of columns of nfeature total - of size ranging between min_features and max_features. - Models are labeled with a tuple of the feature names. - The names of the columns default to strings of integers - from range(nfeatures). - - """ - if (custom_feature_names is not None - and len(custom_feature_names) != nfeatures): - raise ValueError('If custom_feature_names is not None, ' - 'the number of elements in custom_feature_names ' - 'must equal the number of columns in X.') - if custom_feature_names is None: - custom_feature_names = ['%d' % i for i in range(nfeatures)] - - if (not isinstance(max_features, int) or - (max_features > nfeatures or max_features < 1)): - raise AttributeError('max_features must be' - ' smaller than %d and larger than 0' % - (nfeatures + 1)) - - if (not isinstance(min_features, int) or - (min_features > nfeatures or min_features < 1)): - raise AttributeError('min_features must be' - ' smaller than %d and larger than 0' - % (nfeatures + 1)) - - if max_features < min_features: - raise AttributeError('min_features must be <= max_features') - - chain_ = lambda i: ((c, tuple([custom_feature_names[n] for n in c])) for c in combinations(range(nfeatures), r=i)) - - candidates = chain.from_iterable(chain_(i) for i in - range(min_features, max_features + 1)) - - return candidates - From beca2d95a500e402b475e9264346b51c49874784 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Mon, 4 Oct 2021 21:46:11 -0700 Subject: [PATCH 06/14] reverting tests to previous version --- .../tests/test_exhaustive_feature_selector.py | 122 +++++++++--------- 1 file changed, 58 insertions(+), 64 deletions(-) diff --git a/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py b/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py index ab4e39ea8..8927f264a 100644 --- a/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py +++ b/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py @@ -10,7 +10,6 @@ from distutils.version import LooseVersion as Version from numpy.testing import assert_almost_equal from mlxtend.feature_selection import ExhaustiveFeatureSelector as EFS -from mlxtend.feature_selection.exhaustive_feature_selector import min_max_candidates from sklearn.ensemble import RandomForestClassifier from sklearn.neighbors import KNeighborsClassifier from mlxtend.classifier import SoftmaxRegression @@ -47,42 +46,51 @@ def test_minfeatures_1(): iris = load_iris() X = iris.data y = iris.target + knn = KNeighborsClassifier() + efs = EFS(estimator=knn, + min_features=0, + max_features=2) expect = ('min_features must be smaller than 5 and larger than 0') assert_raises(AttributeError, expect, - min_max_candidates, - X.shape[1], - 0, - 2) + efs.fit, + X, + y) def test_maxfeatures_1(): iris = load_iris() X = iris.data y = iris.target + knn = KNeighborsClassifier() + efs = EFS(estimator=knn, + min_features=1, + max_features=0) expect = ('max_features must be smaller than 5 and larger than 0') assert_raises(AttributeError, expect, - min_max_candidates, - X.shape[1], - 1, - 0) + efs.fit, + X, + y) def test_minmaxfeatures_1(): iris = load_iris() X = iris.data y = iris.target + knn = KNeighborsClassifier() + efs = EFS(estimator=knn, + min_features=3, + max_features=2) expect = ('min_features must be <= max_features') assert_raises(AttributeError, expect, - min_max_candidates, - X.shape[1], - 3, - 2) + efs.fit, + X, + y) def test_knn_wo_cv(): @@ -91,13 +99,12 @@ def test_knn_wo_cv(): y = iris.target knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, + min_features=2, + max_features=3, scoring='accuracy', cv=0, print_progress=False) - candidates = min_max_candidates(X.shape[1], - min_features=2, - max_features=3) - efs1 = efs1.fit(X, y, candidates) + efs1 = efs1.fit(X, y) expect = {0: {'feature_idx': (0, 1), 'feature_names': ('0', '1'), 'avg_score': 0.82666666666666666, @@ -147,13 +154,12 @@ def test_knn_cv3(): y = iris.target knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, + min_features=3, + max_features=3, scoring='accuracy', cv=4, print_progress=False) - candidates = min_max_candidates(X.shape[1], - min_features=3, - max_features=3) - efs1 = efs1.fit(X, y, candidates) + efs1 = efs1.fit(X, y) expect = {0: {'avg_score': 0.9391025641025641, 'feature_idx': (0, 1, 2), 'feature_names': ('0', '1', '2'), @@ -196,15 +202,14 @@ def test_knn_cv3_groups(): y = iris.target knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, + min_features=3, + max_features=3, scoring='accuracy', cv=GroupKFold(n_splits=3), print_progress=False) np.random.seed(1630672634) - candidates = min_max_candidates(X.shape[1], - min_features=3, - max_features=3) groups = np.random.randint(0, 6, size=len(y)) - efs1 = efs1.fit(X, y, candidates, groups=groups) + efs1 = efs1.fit(X, y, groups=groups) expect = {0: {'cv_scores': np.array([0.97916667, 0.93877551, 0.9245283]), 'feature_idx': (0, 1, 2), @@ -232,14 +237,12 @@ def test_fit_params(): sample_weight = np.ones(X.shape[0]) forest = RandomForestClassifier(n_estimators=100, random_state=123) efs1 = EFS(forest, + min_features=3, + max_features=3, scoring='accuracy', cv=4, print_progress=False) - - candidates = min_max_candidates(X.shape[1], - min_features=3, - max_features=3) - efs1 = efs1.fit(X, y, candidates, sample_weight=sample_weight) + efs1 = efs1.fit(X, y, sample_weight=sample_weight) expect = {0: {'feature_idx': (0, 1, 2), 'feature_names': ('0', '1', '2'), 'cv_scores': np.array([0.947, 0.868, 0.919, 0.973]), @@ -283,13 +286,12 @@ def test_regression(): X, y = boston.data[:, [1, 2, 6, 8, 12]], boston.target lr = LinearRegression() efs_r = EFS(lr, + min_features=3, + max_features=4, scoring='neg_mean_squared_error', cv=10, print_progress=False) - candidates = min_max_candidates(X.shape[1], - min_features=3, - max_features=4) - efs_r = efs_r.fit(X, y, candidates) + efs_r = efs_r.fit(X, y) assert efs_r.best_idx_ == (0, 2, 4) assert round(efs_r.best_score_, 4) == -40.8777 @@ -356,6 +358,8 @@ def _predict(self, X): expect, EFS, Perceptron, + min_features=2, + max_features=2, clone_estimator=True) @@ -365,15 +369,14 @@ def test_clone_params_pass(): y = iris.target lr = SoftmaxRegression(random_seed=1) efs1 = EFS(lr, + min_features=2, + max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) - candidates = min_max_candidates(X.shape[1], - min_features=2, - max_features=2) - efs1 = efs1.fit(X, y, candidates) + efs1 = efs1.fit(X, y) assert(efs1.best_idx_ == (1, 3)) @@ -383,6 +386,8 @@ def test_transform_not_fitted(): knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, + min_features=2, + max_features=2, scoring='accuracy', cv=0, clone_estimator=False, @@ -404,17 +409,15 @@ def test_fit_transform(): knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, + min_features=2, + max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) - candidates = min_max_candidates(X.shape[1], - min_features=2, - max_features=2) - - X_t = efs1.fit_transform(X, y, candidates) + X_t = efs1.fit_transform(X, y) assert X_t.shape == (150, 2) @@ -422,6 +425,8 @@ def test_get_metric_dict_not_fitted(): knn = KNeighborsClassifier(n_neighbors=4) efs1 = EFS(knn, + min_features=2, + max_features=2, scoring='accuracy', cv=0, clone_estimator=False, @@ -441,19 +446,16 @@ def test_custom_feature_names(): X = iris.data y = iris.target efs1 = EFS(knn, + min_features=2, + max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) - candidates = min_max_candidates(X.shape[1], - min_features=2, - max_features=2, - custom_feature_names=( + efs1 = efs1.fit(X, y, custom_feature_names=( 'sepal length', 'sepal width', 'petal length', 'petal width')) - - efs1 = efs1.fit(X, y, candidates) assert efs1.best_idx_ == (2, 3), efs1.best_idx_ assert efs1.best_feature_names_ == ('petal length', 'petal width') @@ -465,6 +467,8 @@ def test_check_pandas_dataframe_fit(): X = iris.data y = iris.target efs1 = EFS(knn, + min_features=2, + max_features=2, scoring='accuracy', cv=0, clone_estimator=False, @@ -474,20 +478,13 @@ def test_check_pandas_dataframe_fit(): df = pd.DataFrame(X, columns=['sepal length', 'sepal width', 'petal length', 'petal width']) - candidates = min_max_candidates(X.shape[1], - min_features=2, - max_features=2) - sfs1 = efs1.fit(X, y, candidates) + sfs1 = efs1.fit(X, y) assert efs1.best_idx_ == (2, 3), efs1.best_idx_ assert efs1.best_feature_names_ == ('2', '3') assert efs1.interrupted_ is False sfs1._TESTING_INTERRUPT_MODE = True - candidates = min_max_candidates(X.shape[1], - min_features=2, - max_features=2, - custom_feature_names=df.columns) - sfs1 = sfs1.fit(df, y, candidates) + sfs1 = sfs1.fit(df, y) assert efs1.best_idx_ == (0, 1), efs1.best_idx_ assert efs1.best_feature_names_ == ('sepal length', 'sepal width') assert efs1.interrupted_ is True @@ -499,19 +496,16 @@ def test_check_pandas_dataframe_transform(): X = iris.data y = iris.target efs1 = EFS(knn, + min_features=2, + max_features=2, scoring='accuracy', cv=0, clone_estimator=False, print_progress=False, n_jobs=1) - df = pd.DataFrame(X, columns=['sepal length', 'sepal width', 'petal length', 'petal width']) - candidates = min_max_candidates(X.shape[1], - min_features=2, - max_features=2, - custom_feature_names=df.columns) - efs1 = efs1.fit(df, y, candidates) + efs1 = efs1.fit(df, y) assert efs1.best_idx_ == (2, 3) assert (150, 2) == efs1.transform(df).shape From c19e4c12cb52e9133349674f670ff9d1f404d1d9 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Tue, 5 Oct 2021 09:42:47 -0700 Subject: [PATCH 07/14] using _get_column with optional iloc for all direct column access --- mlxtend/feature_selection/columns.py | 23 ++- mlxtend/feature_selection/generic_selector.py | 169 +++++++++--------- 2 files changed, 95 insertions(+), 97 deletions(-) diff --git a/mlxtend/feature_selection/columns.py b/mlxtend/feature_selection/columns.py index 50d767ba0..c74d65196 100644 --- a/mlxtend/feature_selection/columns.py +++ b/mlxtend/feature_selection/columns.py @@ -88,7 +88,7 @@ def fit_encoder(self, X): self.encoder.fit(cols) return np.asarray(cols) -def _get_column(idx, X, twodim=False): +def _get_column(idx, X, twodim=False, loc=True): """ Extract column `idx` from `X`, optionally making it two-dimensional @@ -97,8 +97,13 @@ def _get_column(idx, X, twodim=False): """ if isinstance(X, np.ndarray): col = X[:,idx] - else: # assuming pd.DataFrame - col = X[idx] + elif hasattr(X, 'loc'): + if loc: + col = X.loc[:,idx] + else: # use iloc + col = X.iloc[:,idx] + else: + raise ValueError('expecting an ndarray or a "loc/iloc" methods, got %s' % str(X)) if twodim and np.asarray(col).ndim == 1: return np.asarray(col).reshape((-1,1)) return np.asarray(col) @@ -205,14 +210,9 @@ def _check_categories(categorical_features, X): # stopping, the mapper only gets a fraction of the training data. known_categories = [] - if hasattr(X, 'loc'): # hacky way to assume pd.DataFrame without importing pd - X_list = [X[c] for c in X.columns] - else: - X_list = X.T - for f_idx in range(n_features): if is_categorical[f_idx]: - categories = np.unique(X_list[f_idx]) + categories = np.array([v for v in set(_get_column(f_idx, X, loc=False))]) missing = [] for c in categories: try: @@ -221,7 +221,7 @@ def _check_categories(categorical_features, X): missing.append(False) missing = np.array(missing) if missing.any(): - categories = categories[~missing] + categories = sorted(categories[~missing]) else: categories = None @@ -231,8 +231,7 @@ def _check_categories(categorical_features, X): def _categorical_from_df(df): """ - Find categorical and ordinal - variables in a data frame. + Find """ is_categorical = [] is_ordinal = [] diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py index 18dde5904..6eaeaed21 100644 --- a/mlxtend/feature_selection/generic_selector.py +++ b/mlxtend/feature_selection/generic_selector.py @@ -37,15 +37,15 @@ class Strategy(NamedTuple): """ - initial_state : object + initial_state: object Initial state of feature selector. - state_generator : callable + state_generator: callable Callable taking single argument `state` and returning candidates for next batch of scores to be calculated. - build_submodel : callable + build_submodel: callable Callable taking two arguments `(X, state)` that returns model matrix represented by `state`. - check_finished : callable + check_finished: callable Callable taking three arguments `(results, best_state, batch_results)` which determines if the state generator should step. Often will just check @@ -53,10 +53,10 @@ class Strategy(NamedTuple): but can use entire set of results if desired. """ - initial_state : Any - candidate_states : Callable - build_submodel : Callable - check_finished : Callable + initial_state: Any + candidate_states: Callable + build_submodel: Callable + check_finished: Callable def _calc_score(selector, build_submodel, @@ -94,18 +94,18 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): Parameters ---------- - estimator : scikit-learn classifier or regressor - strategy : Strategy + estimator: scikit-learn classifier or regressor + strategy: Strategy Description of search strategy: a named tuple with fields `initial_state`, `candidate_states`, `build_submodel`, `check_finished`. - verbose : int (default: 0), level of verbosity to use in logging. + verbose: int (default: 0), level of verbosity to use in logging. If 0, no output, if 1 number of features in current set, if 2 detailed logging including timestamp and cv scores at step. - scoring : str, callable, or None (default: None) + scoring: str, callable, or None (default: None) If None (default), uses 'accuracy' for sklearn classifiers and 'r2' for sklearn regressors. If str, uses a sklearn scoring metric string identifier, for example @@ -116,15 +116,15 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): sklearn's signature ``scorer(estimator, X, y)``; see http://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html for more information. - cv : int (default: 5) + cv: int (default: 5) Integer or iterable yielding train, test splits. If cv is an integer and `estimator` is a classifier (or y consists of integer class labels) stratified k-fold. Otherwise regular k-fold cross-validation is performed. No cross-validation if cv is None, False, or 0. - n_jobs : int (default: 1) + n_jobs: int (default: 1) The number of CPUs to use for evaluating different feature subsets in parallel. -1 means 'all CPUs'. - pre_dispatch : int, or string (default: '2*n_jobs') + pre_dispatch: int, or string (default: '2*n_jobs') Controls the number of jobs that get dispatched during parallel execution if `n_jobs > 1` or `n_jobs=-1`. Reducing this number can be useful to avoid an explosion of @@ -136,7 +136,7 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): An int, giving the exact number of total jobs that are spawned A string, giving an expression as a function of n_jobs, as in `2*n_jobs` - clone_estimator : bool (default: True) + clone_estimator: bool (default: True) Clones estimator if True; works with the original estimator instance if False. Set to False if the estimator doesn't implement scikit-learn's set_params and get_params methods. @@ -144,7 +144,7 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): Attributes ---------- - results_ : dict + results_: dict A dictionary of selected feature subsets during the selection, where the dictionary keys are the states of these feature selector. The dictionary @@ -248,29 +248,29 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): Parameters ---------- - X : {array-like, sparse matrix}, shape = [n_samples, n_features] + X: {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. New in v 0.13.0: pandas DataFrames are now also accepted as argument for X. - y : array-like, shape = [n_samples] + y: array-like, shape = [n_samples] Target values. New in v 0.13.0: pandas DataFrames are now also accepted as argument for y. - custom_feature_names : None or tuple (default: tuple) + custom_feature_names: None or tuple (default: tuple) Custom feature names for `self.k_feature_names` and `self.subsets_[i]['feature_names']`. (new in v 0.13.0) - groups : array-like, with shape (n_samples,), optional + groups: array-like, with shape (n_samples,), optional Group labels for the samples used while splitting the dataset into train/test set. Passed to the fit method of the cross-validator. - fit_params : various, optional + fit_params: various, optional Additional parameters that are being passed to the estimator. For example, `sample_weights=weights`. Returns ------- - self : object + self: object """ @@ -333,7 +333,7 @@ def transform(self, X): Parameters ---------- - X : {array-like, sparse matrix}, shape = [n_samples, n_features] + X: {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. New in v 0.13.0: pandas DataFrames are now also accepted as @@ -356,19 +356,19 @@ def fit_transform(self, Parameters ---------- - X : {array-like, sparse matrix}, shape = [n_samples, n_features] + X: {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. New in v 0.13.0: pandas DataFrames are now also accepted as argument for X. - y : array-like, shape = [n_samples] + y: array-like, shape = [n_samples] Target values. New in v 0.13.0: a pandas Series are now also accepted as argument for y. - groups : array-like, with shape (n_samples,), optional + groups: array-like, with shape (n_samples,), optional Group labels for the samples used while splitting the dataset into train/test set. Passed to the fit method of the cross-validator. - fit_params : various, optional + fit_params: various, optional Additional parameters that are being passed to the estimator. For example, `sample_weights=weights`. @@ -385,7 +385,7 @@ def get_metric_dict(self, confidence_interval=0.95): Parameters ---------- - confidence_interval : float (default: 0.95) + confidence_interval: float (default: 0.95) A positive float between 0.0 and 1.0 to compute the confidence interval bounds of the CV score averages. @@ -471,13 +471,13 @@ def _update_results_check(self, Parameters ---------- - batch_results : dict + batch_results: dict Dictionary of results from a batch fit. Keys are the state with values dictionaries having keys `cv_scores`, `avg_scores`. - check_finished : callable + check_finished: callable Callable taking three arguments `(results, best_state, batch_results)` which determines if the state generator should step. Often will just check @@ -487,10 +487,10 @@ def _update_results_check(self, Returns ------- - best_state : object + best_state: object State that had the best `avg_score` - fitted : bool + fitted: bool If batch_results is empty, fitting has terminated so return True. Otherwise False. @@ -539,30 +539,30 @@ def __init__(self, """ Parameters ---------- - X : {array-like, sparse matrix}, shape = [n_samples, n_features] + X: {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. New in v 0.13.0: pandas DataFrames are now also accepted as argument for X. - min_features : int (default: 1) + min_features: int (default: 1) Minumum number of features to select - max_features : int (default: 1) + max_features: int (default: 1) Maximum number of features to select - fixed_features : column identifiers, default=None + fixed_features: column identifiers, default=None Subset of features to keep. Stored as `self.columns[fixed_features]` where `self.columns` will correspond to columns if X is a `pd.DataFrame` or an array of integers if X is an `np.ndarray` - custom_feature_names : None or tuple (default: tuple) + custom_feature_names: None or tuple (default: tuple) Custom feature names for `self.k_feature_names` and `self.subsets_[i]['feature_names']`. (new in v 0.13.0) - categorical_features : array-like of {bool, int} of shape (n_features) + categorical_features: array-like of {bool, int} of shape (n_features) or shape (n_categorical_features,), default=None. Indicates the categorical features. - - None : no feature will be considered categorical. - - boolean array-like : boolean mask indicating categorical features. - - integer array-like : integer indices indicating categorical + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical features. For each categorical feature, there must be at most `max_bins` unique @@ -648,11 +648,11 @@ def candidate_states(self, state): Parameters ---------- - state : ignored + state: ignored Returns ------- - candidates : iterator + candidates: iterator A generator of (indices, label) where indices are columns of X and label is a name for the given model. The iterator cycles through @@ -701,32 +701,32 @@ def __init__(self, """ Parameters ---------- - X : {array-like, sparse matrix}, shape = [n_samples, n_features] + X: {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. New in v 0.13.0: pandas DataFrames are now also accepted as argument for X. - direction : str + direction: str One of ['forward', 'backward', 'both'] - min_features : int (default: 1) + min_features: int (default: 1) Minumum number of features to select - max_features : int (default: 1) + max_features: int (default: 1) Maximum number of features to select - fixed_features : column identifiers, default=None + fixed_features: column identifiers, default=None Subset of features to keep. Stored as `self.columns[fixed_features]` where `self.columns` will correspond to columns if X is a `pd.DataFrame` or an array of integers if X is an `np.ndarray` - custom_feature_names : None or tuple (default: tuple) + custom_feature_names: None or tuple (default: tuple) Custom feature names for `self.k_feature_names` and `self.subsets_[i]['feature_names']`. (new in v 0.13.0) - categorical_features : array-like of {bool, int} of shape (n_features) + categorical_features: array-like of {bool, int} of shape (n_features) or shape (n_categorical_features,), default=None. Indicates the categorical features. - - None : no feature will be considered categorical. - - boolean array-like : boolean mask indicating categorical features. - - integer array-like : integer indices indicating categorical + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical features. For each categorical feature, there must be at most `max_bins` unique @@ -761,11 +761,11 @@ def candidate_states(self, state): Parameters ---------- - state : ignored + state: ignored Returns ------- - candidates : iterator + candidates: iterator A generator of (indices, label) where indices are columns of X and label is a name for the given model. The iterator cycles through @@ -818,7 +818,6 @@ def check_finished(self, batch_best_state = state finished = batch_best_score <= results[best_state]['avg_score'] - print(batch_best_state, batch_best_score, results[best_state]['avg_score'], finished, 'BEST!!!!!!!!!!!!!!!!!!!!!!!') return batch_best_state, batch_best_score, finished @@ -831,30 +830,30 @@ def min_max(X, """ Parameters ---------- - X : {array-like, sparse matrix}, shape = [n_samples, n_features] + X: {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. New in v 0.13.0: pandas DataFrames are now also accepted as argument for X. - min_features : int (default: 1) + min_features: int (default: 1) Minumum number of features to select - max_features : int (default: 1) + max_features: int (default: 1) Maximum number of features to select - fixed_features : column identifiers, default=None + fixed_features: column identifiers, default=None Subset of features to keep. Stored as `self.columns[fixed_features]` where `self.columns` will correspond to columns if X is a `pd.DataFrame` or an array of integers if X is an `np.ndarray` - custom_feature_names : None or tuple (default: tuple) + custom_feature_names: None or tuple (default: tuple) Custom feature names for `self.k_feature_names` and `self.subsets_[i]['feature_names']`. (new in v 0.13.0) - categorical_features : array-like of {bool, int} of shape (n_features) + categorical_features: array-like of {bool, int} of shape (n_features) or shape (n_categorical_features,), default=None. Indicates the categorical features. - - None : no feature will be considered categorical. - - boolean array-like : boolean mask indicating categorical features. - - integer array-like : integer indices indicating categorical + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical features. For each categorical feature, there must be at most `max_bins` unique @@ -863,19 +862,19 @@ def min_max(X, Returns ------- - initial_state : tuple + initial_state: tuple (column_names, feature_idx) - state_generator : callable + state_generator: callable Object that proposes candidates based on current state. Takes a single argument `state` - build_submodel : callable + build_submodel: callable Candidate generator that enumerate all valid subsets of columns. - check_finished : callable + check_finished: callable Check whether to stop. Takes two arguments: `best_result` a dict with keys ['cv_scores', 'avg_score']; and `state`. @@ -918,37 +917,37 @@ def step(X, """ Parameters ---------- - X : {array-like, sparse matrix}, shape = [n_samples, n_features] + X: {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. New in v 0.13.0: pandas DataFrames are now also accepted as argument for X. - direction : str + direction: str One of ['forward', 'backward', 'both'] - min_features : int (default: 1) + min_features: int (default: 1) Minumum number of features to select - max_features : int (default: 1) + max_features: int (default: 1) Maximum number of features to select - fixed_features : column identifiers, default=None + fixed_features: column identifiers, default=None Subset of features to keep. Stored as `self.columns[fixed_features]` where `self.columns` will correspond to columns if X is a `pd.DataFrame` or an array of integers if X is an `np.ndarray` - initial_features : column identifiers, default=None + initial_features: column identifiers, default=None Subset of features to be used to initialize when direction is `both`. If None defaults to behavior of `forward`. where `self.columns` will correspond to columns if X is a `pd.DataFrame` or an array of integers if X is an `np.ndarray` - custom_feature_names : None or tuple (default: tuple) + custom_feature_names: None or tuple (default: tuple) Custom feature names for `self.k_feature_names` and `self.subsets_[i]['feature_names']`. (new in v 0.13.0) - categorical_features : array-like of {bool, int} of shape (n_features) + categorical_features: array-like of {bool, int} of shape (n_features) or shape (n_categorical_features,), default=None. Indicates the categorical features. - - None : no feature will be considered categorical. - - boolean array-like : boolean mask indicating categorical features. - - integer array-like : integer indices indicating categorical + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical features. For each categorical feature, there must be at most `max_bins` unique @@ -957,19 +956,19 @@ def step(X, Returns ------- - initial_state : tuple + initial_state: tuple (column_names, feature_idx) - state_generator : callable + state_generator: callable Object that proposes candidates based on current state. Takes a single argument `state` - build_submodel : callable + build_submodel: callable Candidate generator that enumerate all valid subsets of columns. - check_finished : callable + check_finished: callable Check whether to stop. Takes two arguments: `best_result` a dict with keys ['cv_scores', 'avg_score']; and `state`. From 72b6f553bba9efd662ec9887bf1605d98fbe40f5 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Tue, 5 Oct 2021 09:53:11 -0700 Subject: [PATCH 08/14] some lint cleanup --- mlxtend/feature_selection/columns.py | 57 +++++++++++++++++++--------- 1 file changed, 39 insertions(+), 18 deletions(-) diff --git a/mlxtend/feature_selection/columns.py b/mlxtend/feature_selection/columns.py index c74d65196..281955d67 100644 --- a/mlxtend/feature_selection/columns.py +++ b/mlxtend/feature_selection/columns.py @@ -9,6 +9,7 @@ from sklearn.utils.validation import check_is_fitted from sklearn.exceptions import NotFittedError + class Column(NamedTuple): """ @@ -22,7 +23,7 @@ class Column(NamedTuple): is_ordinal: bool = False columns: tuple = () encoder: Any = None - + def get_columns(self, X, fit=False): """ @@ -58,12 +59,14 @@ def get_columns(self, X, fit=False): if self.encoder is not None: cols = self.encoder.transform(cols) cols = np.asarray(cols) - + names = self.columns if hasattr(self.encoder, 'columns_'): - names = ['{0}[{1}]'.format(self.name, c) for c in self.encoder.columns_] + names = ['{0}[{1}]'.format(self.name, c) + for c in self.encoder.columns_] if not names: - names = ['{0}[{1}]'.format(self.name, i) for i in range(cols.shape[1])] + names = ['{0}[{1}]'.format(self.name, i) + for i in range(cols.shape[1])] return cols, names def fit_encoder(self, X): @@ -87,7 +90,11 @@ def fit_encoder(self, X): except NotFittedError: self.encoder.fit(cols) return np.asarray(cols) - + + +# private functions + + def _get_column(idx, X, twodim=False, loc=True): """ Extract column `idx` from `X`, @@ -96,24 +103,32 @@ def _get_column(idx, X, twodim=False, loc=True): two-dimensional input """ if isinstance(X, np.ndarray): - col = X[:,idx] + col = X[:, idx] elif hasattr(X, 'loc'): if loc: - col = X.loc[:,idx] - else: # use iloc - col = X.iloc[:,idx] + col = X.loc[:, idx] + else: # use iloc instead + col = X.iloc[:, idx] else: - raise ValueError('expecting an ndarray or a "loc/iloc" methods, got %s' % str(X)) + raise ValueError('expecting an ndarray or a ' + + '"loc/iloc" methods, got %s' % str(X)) if twodim and np.asarray(col).ndim == 1: - return np.asarray(col).reshape((-1,1)) + return np.asarray(col).reshape((-1, 1)) return np.asarray(col) + def _get_column_info(X, columns, is_categorical, is_ordinal, - default_encoders={'categorical': OneHotEncoder(drop='first', sparse=False), - 'ordinal': OrdinalEncoder()}): + default_encoders={ + 'ordinal': OrdinalEncoder(), + 'categorical': OneHotEncoder(drop='first', + sparse=False) + } + ): + + """ Compute a dictionary of `Column` instances for each column @@ -123,6 +138,7 @@ def _get_column_info(X, default encoding provided. """ + column_info = {} for i, col in enumerate(columns): if type(col) == int: @@ -142,7 +158,8 @@ def _get_column_info(X, columns_ = encoder.columns_ else: columns_ = range(cols.shape[1]) - columns = ['Cat({0})[{1}]'.format(col, c) for c in range(cols.shape[1])] + columns = ['Cat({0})[{1}]'.format(col, c) + for c in range(cols.shape[1])] column_info[col] = Column(col, name, @@ -159,6 +176,8 @@ def _get_column_info(X, # extracted from method of BaseHistGradientBoosting from # https://github.com/scikit-learn/scikit-learn/blob/2beed55847ee70d363bdbfe14ee4401438fba057/sklearn/ensemble/_hist_gradient_boosting/gradient_boosting.py # max_bins is ignored + + def _check_categories(categorical_features, X): """Check and validate categorical features in X @@ -212,12 +231,15 @@ def _check_categories(categorical_features, X): for f_idx in range(n_features): if is_categorical[f_idx]: - categories = np.array([v for v in set(_get_column(f_idx, X, loc=False))]) + categories = np.array([v for v in + set(_get_column(f_idx, + X, + loc=False))]) missing = [] for c in categories: try: missing.append(np.isnan(c)) - except TypeError: # not a float + except TypeError: # not a float missing.append(False) missing = np.array(missing) if missing.any(): @@ -229,6 +251,7 @@ def _check_categories(categorical_features, X): return is_categorical, known_categories + def _categorical_from_df(df): """ Find @@ -246,5 +269,3 @@ def _categorical_from_df(df): is_ordinal = np.array(is_ordinal) return is_categorical, is_ordinal - - From 2d817d1c7ac92777043a78cbf9c7fa063992d0ad Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Tue, 5 Oct 2021 16:06:21 -0700 Subject: [PATCH 09/14] added postprocess as part of strategy; implemented a parsimonious version (1sd rule) --- mlxtend/feature_selection/generic_selector.py | 272 +++++++++++++----- .../tests/test_generic_selector.py | 2 +- 2 files changed, 194 insertions(+), 80 deletions(-) diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py index 6eaeaed21..812a87293 100644 --- a/mlxtend/feature_selection/generic_selector.py +++ b/mlxtend/feature_selection/generic_selector.py @@ -57,35 +57,7 @@ class Strategy(NamedTuple): candidate_states: Callable build_submodel: Callable check_finished: Callable - -def _calc_score(selector, - build_submodel, - X, - y, - state, - groups=None, - **fit_params): - - X_state = build_submodel(X, state) - - if selector.cv: - scores = cross_val_score(selector.est_, - X_state, - y, - groups=groups, - cv=selector.cv, - scoring=selector.scorer, - n_jobs=1, - pre_dispatch=selector.pre_dispatch, - fit_params=fit_params) - else: - selector.est_.fit(X_state, - y, - **fit_params) - scores = np.array([selector.scorer(selector.est_, - X_state, - y)]) - return state, scores + postprocess: Callable class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): @@ -99,7 +71,7 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): Description of search strategy: a named tuple with fields `initial_state`, `candidate_states`, `build_submodel`, - `check_finished`. + `check_finished` and `postprocess`. verbose: int (default: 0), level of verbosity to use in logging. If 0, no output, @@ -149,7 +121,7 @@ class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): selection, where the dictionary keys are the states of these feature selector. The dictionary values are dictionaries themselves with the following - keys: 'cv_scores' (list individual cross-validation scores) + keys: 'scores' (list individual cross-validation scores) 'avg_score' (average cross-validation score) Notes @@ -211,8 +183,6 @@ def __init__(self, self.scorer = scoring self.fitted = False - self.results_ = {} - self.interrupted_ = False # don't mess with this unless testing self._TESTING_INTERRUPT_MODE = False @@ -275,36 +245,45 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): """ # reset from a potential previous fit run - self.results_ = {} - self.finished = False self.interrupted_ = False + self.finished_ = False + + results_ = {} # unpack the strategy - initial_state, candidate_states, build_submodel, check_finished = self.strategy + (initial_state, + candidate_states, + build_submodel, + check_finished, + postprocess) = self.strategy # fit initial model - - _state, _scores = _calc_score(self, + _state, _scores = _calc_score(self.estimator, + self.scorer, build_submodel, X, y, initial_state, groups=groups, + cv=self.cv, + pre_dispatch=self.pre_dispatch, **fit_params) # keep a running track of the best state + self.path_ = [deepcopy(_state)] self.best_state_ = _state self.best_score_ = np.nanmean(_scores) - self._update_results_check({_state: {'cv_scores': _scores, - 'avg_score': np.nanmean(_scores)}}, - check_finished) + self.update_results_check(results_, + {_state: {'scores': _scores, + 'avg_score': np.nanmean(_scores)}}, + check_finished) try: - while not self.finished: + while not self.finished_: batch_results = self._batch(_state, candidate_states(_state), @@ -314,9 +293,12 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): groups=groups, **fit_params) - _state, _score, self.finished = self._update_results_check(batch_results, + _state, _score, self.finished_ = self.update_results_check(results_, + batch_results, check_finished) + self.path_.append(deepcopy(_state)) + if self._TESTING_INTERRUPT_MODE: raise KeyboardInterrupt @@ -324,8 +306,8 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): self.interrupted_ = True sys.stderr.write('\nSTOPPING EARLY DUE TO KEYBOARD INTERRUPT...') + self.selected_state_, self.results_ = postprocess(results_) self.fitted = True - self.postprocess() return self def transform(self, X): @@ -345,7 +327,8 @@ def transform(self, X): """ self._check_fitted() - return self.strategy.build_submodel(X, self.best_state_) + build_submodel = self.strategy.build_submodel + return build_submodel(X, self.selected_state_) def fit_transform(self, X, @@ -396,7 +379,7 @@ def get_metric_dict(self, confidence_interval=0.95): its length. The dictionary keys corresponding to these lists are as follows: 'state': tuple of the indices of the feature subset - 'cv_scores': list with individual CV scores + 'scores': list with individual CV scores 'avg_score': of CV average scores 'std_dev': standard deviation of the CV score average 'std_err': standard error of the CV score average @@ -412,9 +395,9 @@ def _calc_confidence(ary, confidence=0.95): return bound, std_err for k in fdict: - std_dev = np.std(self.results_[k]['cv_scores']) + std_dev = np.std(self.results_[k]['scores']) bound, std_err = self._calc_confidence( - self.results_[k]['cv_scores'], + self.results_[k]['scores'], confidence=confidence_interval) fdict[k]['ci_bound'] = bound fdict[k]['std_dev'] = std_dev @@ -441,18 +424,21 @@ def _batch(self, pre_dispatch=self.pre_dispatch) work = parallel(delayed(_calc_score) - (self, + (self.estimator, + self.scorer, build_submodel, X, y, state, groups=groups, + cv=self.cv, + pre_dispatch=self.pre_dispatch, **fit_params) for state in candidates) - for state, cv_scores in work: - results[state] = {'cv_scores': cv_scores, - 'avg_score': np.nanmean(cv_scores)} + for state, scores in work: + results[state] = {'scores': scores, + 'avg_score': np.nanmean(scores)} return results @@ -460,22 +446,29 @@ def _check_fitted(self): if not self.fitted: raise AttributeError('{} has not been fitted yet.'.format(self.__class__)) - def _update_results_check(self, - batch_results, - check_finished): + def update_results_check(self, + results, + batch_results, + check_finished): """ - Update `self.results_` with current batch + Update `results_` with current batch and return a boolean about whether we should continue or not. Parameters ---------- + results: dict + Dictionary of all results. + Keys are state with values + dictionaries having keys + `scores`, `avg_scores`. + batch_results: dict Dictionary of results from a batch fit. - Keys are the state with values + Keys are tate with values dictionaries having keys - `cv_scores`, `avg_scores`. + `scores`, `avg_scores`. check_finished: callable Callable taking three arguments @@ -500,11 +493,11 @@ def _update_results_check(self, finished = batch_results == {} if not finished: - self.results_.update(batch_results) + results.update(batch_results) (cur_state, cur_score, - finished) = check_finished(self.results_, + finished) = check_finished(results, self.best_state_, batch_results) if cur_score > self.best_score_: @@ -514,19 +507,7 @@ def _update_results_check(self, else: return None, None, True - def postprocess(self): - """ - Find the best model and score from `self.results_`. - """ - - self.best_state_ = None - self.best_score_ = -np.inf - - for state, result in self.results_.items(): - if result['avg_score'] > self.best_score_: - self.best_state_ = state - self.best_score_ = result['avg_score'] - + class MinMaxCandidates(object): def __init__(self, @@ -826,7 +807,8 @@ def min_max(X, max_features=1, fixed_features=None, custom_feature_names=None, - categorical_features=None): + categorical_features=None, + parsimonious=True): """ Parameters ---------- @@ -859,6 +841,11 @@ def min_max(X, For each categorical feature, there must be at most `max_bins` unique categories, and each categorical value must be in [0, max_bins -1]. + parsimonious: bool + If True, use the 1sd rule: among the shortest models + within one standard deviation of the best score + pick the one with the best average score. + Returns ------- @@ -876,7 +863,7 @@ def min_max(X, check_finished: callable Check whether to stop. Takes two arguments: - `best_result` a dict with keys ['cv_scores', 'avg_score']; + `best_result` a dict with keys ['scores', 'avg_score']; and `state`. """ @@ -900,10 +887,16 @@ def min_max(X, initial_features = range(min_max.min_features) initial_state = tuple(initial_features) + if not parsimonious: + _postprocess = _postprocess_best + else: + _postprocess = _postprocess_best_1sd + return Strategy(initial_state, min_max.candidate_states, build_submodel, - min_max.check_finished) + min_max.check_finished, + _postprocess) def step(X, direction='forward', @@ -913,7 +906,8 @@ def step(X, fixed_features=None, initial_features=None, custom_feature_names=None, - categorical_features=None): + categorical_features=None, + parsimonious=True): """ Parameters ---------- @@ -953,6 +947,11 @@ def step(X, For each categorical feature, there must be at most `max_bins` unique categories, and each categorical value must be in [0, max_bins -1]. + parsimonious: bool + If True, use the 1sd rule: among the shortest models + within one standard deviation of the best score + pick the one with the best average score. + Returns ------- @@ -970,7 +969,7 @@ def step(X, check_finished: callable Check whether to stop. Takes two arguments: - `best_result` a dict with keys ['cv_scores', 'avg_score']; + `best_result` a dict with keys ['scores', 'avg_score']; and `state`. """ @@ -1016,11 +1015,126 @@ def step(X, if not step.fixed_features.issubset(initial_features): raise ValueError('initial_features should contain %s' % str(step.fixed_features)) + if not parsimonious: + _postprocess = _postprocess_best + else: + _postprocess = _postprocess_best_1sd + return Strategy(initial_state, step.candidate_states, build_submodel, - step.check_finished) + step.check_finished, + _postprocess) + + +# private functions + + +def _calc_score(estimator, + scorer, + build_submodel, + X, + y, + state, + groups=None, + cv=None, + pre_dispatch='2*n_jobs', + **fit_params): + + X_state = build_submodel(X, state) + + if cv: + scores = cross_val_score(estimator, + X_state, + y, + groups=groups, + cv=cv, + scoring=scorer, + n_jobs=1, + pre_dispatch=pre_dispatch, + fit_params=fit_params) + else: + estimator.fit(X_state, + y, + **fit_params) + scores = np.array([scorer(estimator, + X_state, + y)]) + return state, scores + def _build_submodel(column_info, X, cols): return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) + +def _postprocess_best(results): + """ + Find the best state from `results` + based on `avg_score`. + + Return best state and results + """ + + best_state = None + best_score = -np.inf + + for state, result in results.items(): + if result['avg_score'] > best_score: + best_state = state + best_score = result['avg_score'] + + return best_state, results + +def _postprocess_best_1sd(results): + """ + Find the best state from `results` + based on `avg_score`. + + Find models satisfying the 1sd rule + and choose the state with best score + among the smallest such states. + + Return best state and results + + Models are compared by length of state + """ + + best_state = None + best_score = -np.inf + + for state, result in results.items(): + if result['avg_score'] > best_score: + best_state = state + best_score = result['avg_score'] + + states_1sd = [] + + for state, result in results.items(): + if len(state) >= len(best_state): + continue + scores = result['scores'] + _limit = (result['avg_score'] + + np.nanstd(scores) / np.sqrt(scores.shape[0])) + if _limit >= best_score: + states_1sd.append(state) + + shortest_1sd = np.inf + + for state in states_1sd: + if len(state) < shortest_1sd: + shortest_1sd = len(state) + + best_state_1sd = None + best_score_1sd = -np.inf + + for state in states_1sd: + if ((len(state) == shortest_1sd) + and (results[state]['avg_score'] <= + best_score_1sd)): + best_state_1sd = state + best_score_1sd = result['avg_score'][state] + + if best_state_1sd: + return best_state_1sd, results + else: + return best_state, results diff --git a/mlxtend/feature_selection/tests/test_generic_selector.py b/mlxtend/feature_selection/tests/test_generic_selector.py index bb78cc219..e793ac3d8 100644 --- a/mlxtend/feature_selection/tests/test_generic_selector.py +++ b/mlxtend/feature_selection/tests/test_generic_selector.py @@ -140,4 +140,4 @@ def test_pandas1(): cv=3) step_selector.fit(D, Y) - + print(step_selector.path_) From 6c98d6e5e7bd6f3f6220f9bbfa6d603a9a85dea2 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Tue, 5 Oct 2021 16:43:21 -0700 Subject: [PATCH 10/14] making a new module for search strategy --- mlxtend/feature_selection/generic_selector.py | 627 ---------------- mlxtend/feature_selection/strategy.py | 671 ++++++++++++++++++ .../tests/test_generic_selector.py | 6 +- 3 files changed, 674 insertions(+), 630 deletions(-) create mode 100644 mlxtend/feature_selection/strategy.py diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py index 812a87293..71ca15e6b 100644 --- a/mlxtend/feature_selection/generic_selector.py +++ b/mlxtend/feature_selection/generic_selector.py @@ -12,53 +12,19 @@ # but allows custom model search import types -from typing import NamedTuple, Any, Callable import sys -from functools import partial from copy import deepcopy -from itertools import combinations, chain import numpy as np import scipy as sp from sklearn.metrics import get_scorer from sklearn.base import (clone, MetaEstimatorMixin) -from sklearn.utils import check_random_state from sklearn.model_selection import cross_val_score from joblib import Parallel, delayed from ..externals.name_estimators import _name_estimators from ..utils.base_compostion import _BaseXComposition -from .columns import (_get_column_info, - Column, - _categorical_from_df, - _check_categories) - -class Strategy(NamedTuple): - - """ - initial_state: object - Initial state of feature selector. - state_generator: callable - Callable taking single argument `state` and returning - candidates for next batch of scores to be calculated. - build_submodel: callable - Callable taking two arguments `(X, state)` that returns - model matrix represented by `state`. - check_finished: callable - Callable taking three arguments - `(results, best_state, batch_results)` which determines if - the state generator should step. Often will just check - if there is a better score than that at current best state - but can use entire set of results if desired. - """ - - initial_state: Any - candidate_states: Callable - build_submodel: Callable - check_finished: Callable - postprocess: Callable - class FeatureSelector(_BaseXComposition, MetaEstimatorMixin): @@ -507,524 +473,7 @@ def update_results_check(self, else: return None, None, True - -class MinMaxCandidates(object): - - def __init__(self, - X, - min_features=1, - max_features=1, - fixed_features=None, - custom_feature_names=None, - categorical_features=None): - """ - Parameters - ---------- - X: {array-like, sparse matrix}, shape = [n_samples, n_features] - Training vectors, where n_samples is the number of samples and - n_features is the number of features. - New in v 0.13.0: pandas DataFrames are now also accepted as - argument for X. - min_features: int (default: 1) - Minumum number of features to select - max_features: int (default: 1) - Maximum number of features to select - fixed_features: column identifiers, default=None - Subset of features to keep. Stored as `self.columns[fixed_features]` - where `self.columns` will correspond to columns if X is a `pd.DataFrame` - or an array of integers if X is an `np.ndarray` - custom_feature_names: None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) - categorical_features: array-like of {bool, int} of shape (n_features) - or shape (n_categorical_features,), default=None. - Indicates the categorical features. - - - None: no feature will be considered categorical. - - boolean array-like: boolean mask indicating categorical features. - - integer array-like: integer indices indicating categorical - features. - - For each categorical feature, there must be at most `max_bins` unique - categories, and each categorical value must be in [0, max_bins -1]. - - """ - - if hasattr(X, 'loc'): - X_ = X.values - is_categorical, is_ordinal = _categorical_from_df(X) - self.columns = X.columns - else: - X_ = X - is_categorical = _check_categories(categorical_features, - X_)[0] - if is_categorical is None: - is_categorical = np.zeros(X_.shape[1], np.bool) - is_ordinal = np.zeros_like(is_categorical) - self.columns = np.arange(X.shape[1]) - - nfeatures = X_.shape[0] - - if (not isinstance(max_features, int) or - (max_features > nfeatures or max_features < 1)): - raise AttributeError('max_features must be' - ' smaller than %d and larger than 0' % - (nfeatures + 1)) - - if (not isinstance(min_features, int) or - (min_features > nfeatures or min_features < 1)): - raise AttributeError('min_features must be' - ' smaller than %d and larger than 0' - % (nfeatures + 1)) - - if max_features < min_features: - raise AttributeError('min_features must be <= max_features') - - self.min_features, self.max_features = min_features, max_features - - # make a mapping from the column info to columns in - # implied design matrix - - self.column_info_ = _get_column_info(X, - self.columns, - is_categorical, - is_ordinal) - self.column_map_ = {} - idx = 0 - for col in self.columns: - l = self.column_info_[col].columns - self.column_map_[col] = range(idx, idx + - len(l)) - idx += len(l) - if (custom_feature_names is not None - and len(custom_feature_names) != nfeatures): - raise ValueError('If custom_feature_names is not None, ' - 'the number of elements in custom_feature_names ' - 'must equal %d the number of columns in X.' % idx) - if custom_feature_names is not None: - # recompute the Column info using custom_feature_names - for i, col in enumerate(self.columns): - cur_col = self.column_info_[col] - new_name = custom_feature_names[i] - old_name = cur_col.name - self.column_info_[col] = Column(col, - new_name, - col.is_categorical, - col.is_ordinal, - tuple([n.replace(old_name, - new_name) for n in col.columns]), - col.encoder) - - self._have_already_run = False - if fixed_features is not None: - self.fixed_features = set([self.column_info_[f].idx for f in fixed_features]) - else: - self.fixed_features = set([]) - - def candidate_states(self, state): - """ - Produce candidates for fitting. - - Parameters - ---------- - - state: ignored - - Returns - ------- - candidates: iterator - A generator of (indices, label) where indices - are columns of X and label is a name for the - given model. The iterator cycles through - all combinations of columns of nfeature total - of size ranging between min_features and max_features. - If appropriate, restricts combinations to include - a set of fixed features. - Models are labeled with a tuple of the feature names. - The names of the columns default to strings of integers - from range(nfeatures). - - """ - - if not self._have_already_run: - self._have_already_run = True # maybe could be done with a StopIteration on candidates? - def chain_(i): - return (c for c in combinations(self.columns, r=i) - if self.fixed_features.issubset(c)) - - candidates = chain.from_iterable(chain_(i) for i in - range(self.min_features, - self.max_features+1)) - return candidates - - def check_finished(self, - results, - best_state, - batch_results): - """ - Check if we should continue or not. - For exhaustive search we stop because - all models are fit in a single batch. - """ - return best_state, results[best_state]['avg_score'], True - -class StepCandidates(MinMaxCandidates): - - def __init__(self, - X, - direction='forward', - min_features=1, - max_features=1, - fixed_features=None, - custom_feature_names=None, - categorical_features=None): - """ - Parameters - ---------- - X: {array-like, sparse matrix}, shape = [n_samples, n_features] - Training vectors, where n_samples is the number of samples and - n_features is the number of features. - New in v 0.13.0: pandas DataFrames are now also accepted as - argument for X. - direction: str - One of ['forward', 'backward', 'both'] - min_features: int (default: 1) - Minumum number of features to select - max_features: int (default: 1) - Maximum number of features to select - fixed_features: column identifiers, default=None - Subset of features to keep. Stored as `self.columns[fixed_features]` - where `self.columns` will correspond to columns if X is a `pd.DataFrame` - or an array of integers if X is an `np.ndarray` - custom_feature_names: None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) - categorical_features: array-like of {bool, int} of shape (n_features) - or shape (n_categorical_features,), default=None. - Indicates the categorical features. - - - None: no feature will be considered categorical. - - boolean array-like: boolean mask indicating categorical features. - - integer array-like: integer indices indicating categorical - features. - - For each categorical feature, there must be at most `max_bins` unique - categories, and each categorical value must be in [0, max_bins -1]. - - """ - - self.direction = direction - MinMaxCandidates.__init__(self, - X, - min_features, - max_features, - fixed_features, - custom_feature_names, - categorical_features) - - def candidate_states(self, state): - """ - Produce candidates for fitting. - For stepwise search this depends on the direction. - - If 'forward', all columns not in the current state - are added (maintaining an upper limit on the number of columns - at `self.max_features`). - - If 'backward', all columns not in the current state - are dropped (maintaining a lower limit on the number of columns - at `self.min_features`). - - All candidates include `self.fixed_features` if any. - - Parameters - ---------- - - state: ignored - - Returns - ------- - candidates: iterator - A generator of (indices, label) where indices - are columns of X and label is a name for the - given model. The iterator cycles through - all combinations of columns of nfeature total - of size ranging between min_features and max_features. - If appropriate, restricts combinations to include - a set of fixed features. - Models are labeled with a tuple of the feature names. - The names of the columns default to strings of integers - from range(nfeatures). - - """ - - state = set(state) - if len(state) < self.max_features: # union - forward = (tuple(sorted(state | set([c]))) for c in self.columns if (c not in state and - self.fixed_features.issubset(state | set([c])))) - else: - forward = None - if len(state) > self.min_features: # symmetric difference - backward = (tuple(sorted(state ^ set([c]))) for c in self.columns if (c in state and - self.fixed_features.issubset(state ^ set([c])))) - else: - backward = None - - if self.direction == 'forward': - return forward - elif self.direction == 'backward': - return backward - else: - return chain.from_iterable([forward, backward]) - - def check_finished(self, - results, - best_state, - batch_results): - """ - Check if we should continue or not. - - For stepwise search we stop if we cannot improve - over our current best score. - - """ - batch_best_score = -np.inf - batch_best_state = None - - for state in batch_results: - if batch_results[state]['avg_score'] > batch_best_score: - batch_best_score = batch_results[state]['avg_score'] - batch_best_state = state - - finished = batch_best_score <= results[best_state]['avg_score'] - return batch_best_state, batch_best_score, finished - - -def min_max(X, - min_features=1, - max_features=1, - fixed_features=None, - custom_feature_names=None, - categorical_features=None, - parsimonious=True): - """ - Parameters - ---------- - X: {array-like, sparse matrix}, shape = [n_samples, n_features] - Training vectors, where n_samples is the number of samples and - n_features is the number of features. - New in v 0.13.0: pandas DataFrames are now also accepted as - argument for X. - min_features: int (default: 1) - Minumum number of features to select - max_features: int (default: 1) - Maximum number of features to select - fixed_features: column identifiers, default=None - Subset of features to keep. Stored as `self.columns[fixed_features]` - where `self.columns` will correspond to columns if X is a `pd.DataFrame` - or an array of integers if X is an `np.ndarray` - custom_feature_names: None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) - categorical_features: array-like of {bool, int} of shape (n_features) - or shape (n_categorical_features,), default=None. - Indicates the categorical features. - - - None: no feature will be considered categorical. - - boolean array-like: boolean mask indicating categorical features. - - integer array-like: integer indices indicating categorical - features. - - For each categorical feature, there must be at most `max_bins` unique - categories, and each categorical value must be in [0, max_bins -1]. - - parsimonious: bool - If True, use the 1sd rule: among the shortest models - within one standard deviation of the best score - pick the one with the best average score. - - Returns - ------- - initial_state: tuple - (column_names, feature_idx) - - state_generator: callable - Object that proposes candidates - based on current state. Takes a single - argument `state` - - build_submodel: callable - Candidate generator that enumerate - all valid subsets of columns. - - check_finished: callable - Check whether to stop. Takes two arguments: - `best_result` a dict with keys ['scores', 'avg_score']; - and `state`. - - """ - - min_max = MinMaxCandidates(X, - min_features, - max_features, - fixed_features, - custom_feature_names, - categorical_features) - - # if any categorical features or an intercept - # is included then we must - # create a new design matrix - - build_submodel = partial(_build_submodel, min_max.column_info_) - - if min_max.fixed_features: - initial_features = sorted(min_max.fixed_features) - else: - initial_features = range(min_max.min_features) - initial_state = tuple(initial_features) - - if not parsimonious: - _postprocess = _postprocess_best - else: - _postprocess = _postprocess_best_1sd - - return Strategy(initial_state, - min_max.candidate_states, - build_submodel, - min_max.check_finished, - _postprocess) - -def step(X, - direction='forward', - min_features=1, - max_features=1, - random_state=0, - fixed_features=None, - initial_features=None, - custom_feature_names=None, - categorical_features=None, - parsimonious=True): - """ - Parameters - ---------- - X: {array-like, sparse matrix}, shape = [n_samples, n_features] - Training vectors, where n_samples is the number of samples and - n_features is the number of features. - New in v 0.13.0: pandas DataFrames are now also accepted as - argument for X. - direction: str - One of ['forward', 'backward', 'both'] - min_features: int (default: 1) - Minumum number of features to select - max_features: int (default: 1) - Maximum number of features to select - fixed_features: column identifiers, default=None - Subset of features to keep. Stored as `self.columns[fixed_features]` - where `self.columns` will correspond to columns if X is a `pd.DataFrame` - or an array of integers if X is an `np.ndarray` - initial_features: column identifiers, default=None - Subset of features to be used to initialize when direction - is `both`. If None defaults to behavior of `forward`. - where `self.columns` will correspond to columns if X is a `pd.DataFrame` - or an array of integers if X is an `np.ndarray` - custom_feature_names: None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) - categorical_features: array-like of {bool, int} of shape (n_features) - or shape (n_categorical_features,), default=None. - Indicates the categorical features. - - - None: no feature will be considered categorical. - - boolean array-like: boolean mask indicating categorical features. - - integer array-like: integer indices indicating categorical - features. - - For each categorical feature, there must be at most `max_bins` unique - categories, and each categorical value must be in [0, max_bins -1]. - - parsimonious: bool - If True, use the 1sd rule: among the shortest models - within one standard deviation of the best score - pick the one with the best average score. - - Returns - ------- - - initial_state: tuple - (column_names, feature_idx) - - state_generator: callable - Object that proposes candidates - based on current state. Takes a single - argument `state` - - build_submodel: callable - Candidate generator that enumerate - all valid subsets of columns. - - check_finished: callable - Check whether to stop. Takes two arguments: - `best_result` a dict with keys ['scores', 'avg_score']; - and `state`. - - """ - - step = StepCandidates(X, - direction, - min_features, - max_features, - fixed_features, - custom_feature_names, - categorical_features) - - # if any categorical features or an intercept - # is included then we must - # create a new design matrix - - build_submodel = partial(_build_submodel, step.column_info_) - - # pick an initial state - - if direction in ['forward', 'both']: - if step.fixed_features: - forward_features = sorted(step.fixed_features) - else: - forward_features = range(step.min_features) - if direction == 'forward': - initial_features = forward_features - else: - if initial_features is None: - initial_features = forward_features - elif direction == 'backward': - if initial_features is None: - random_state = check_random_state(random_state) - initial_features = sorted(random_state.choice([col for col in step.column_info_], - step.max_features, - replace=False)) - initial_state = tuple(initial_features) - - if len(initial_features) > step.max_features: - raise ValueError('initial_features should be of length <= %d' % step.max_features) - if len(initial_features) < step.min_features: - raise ValueError('initial_features should be of length >= %d' % step.min_features) - if not step.fixed_features.issubset(initial_features): - raise ValueError('initial_features should contain %s' % str(step.fixed_features)) - - if not parsimonious: - _postprocess = _postprocess_best - else: - _postprocess = _postprocess_best_1sd - - return Strategy(initial_state, - step.candidate_states, - build_submodel, - step.check_finished, - _postprocess) # private functions @@ -1062,79 +511,3 @@ def _calc_score(estimator, y)]) return state, scores - -def _build_submodel(column_info, X, cols): - return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) - - -def _postprocess_best(results): - """ - Find the best state from `results` - based on `avg_score`. - - Return best state and results - """ - - best_state = None - best_score = -np.inf - - for state, result in results.items(): - if result['avg_score'] > best_score: - best_state = state - best_score = result['avg_score'] - - return best_state, results - -def _postprocess_best_1sd(results): - """ - Find the best state from `results` - based on `avg_score`. - - Find models satisfying the 1sd rule - and choose the state with best score - among the smallest such states. - - Return best state and results - - Models are compared by length of state - """ - - best_state = None - best_score = -np.inf - - for state, result in results.items(): - if result['avg_score'] > best_score: - best_state = state - best_score = result['avg_score'] - - states_1sd = [] - - for state, result in results.items(): - if len(state) >= len(best_state): - continue - scores = result['scores'] - _limit = (result['avg_score'] + - np.nanstd(scores) / np.sqrt(scores.shape[0])) - if _limit >= best_score: - states_1sd.append(state) - - shortest_1sd = np.inf - - for state in states_1sd: - if len(state) < shortest_1sd: - shortest_1sd = len(state) - - best_state_1sd = None - best_score_1sd = -np.inf - - for state in states_1sd: - if ((len(state) == shortest_1sd) - and (results[state]['avg_score'] <= - best_score_1sd)): - best_state_1sd = state - best_score_1sd = result['avg_score'][state] - - if best_state_1sd: - return best_state_1sd, results - else: - return best_state, results diff --git a/mlxtend/feature_selection/strategy.py b/mlxtend/feature_selection/strategy.py new file mode 100644 index 000000000..c3d489271 --- /dev/null +++ b/mlxtend/feature_selection/strategy.py @@ -0,0 +1,671 @@ +# Jonathan Taylor 2021 +# mlxtend Machine Learning Library Extensions +# +# Objects describing search strategy +# Author: Jonathan Taylor +# + +from typing import NamedTuple, Any, Callable +from itertools import chain, combinations +from functools import partial + +import numpy as np +from sklearn.utils import check_random_state + +from .columns import (_get_column_info, + Column, + _categorical_from_df, + _check_categories) + +class Strategy(NamedTuple): + + """ + initial_state: object + Initial state of feature selector. + state_generator: callable + Callable taking single argument `state` and returning + candidates for next batch of scores to be calculated. + build_submodel: callable + Callable taking two arguments `(X, state)` that returns + model matrix represented by `state`. + check_finished: callable + Callable taking three arguments + `(results, best_state, batch_results)` which determines if + the state generator should step. Often will just check + if there is a better score than that at current best state + but can use entire set of results if desired. + """ + + initial_state: Any + candidate_states: Callable + build_submodel: Callable + check_finished: Callable + postprocess: Callable + + +class MinMaxCandidates(object): + + def __init__(self, + X, + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None): + """ + Parameters + ---------- + X: {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + min_features: int (default: 1) + Minumum number of features to select + max_features: int (default: 1) + Maximum number of features to select + fixed_features: column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names: None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features: array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + """ + + if hasattr(X, 'loc'): + X_ = X.values + is_categorical, is_ordinal = _categorical_from_df(X) + self.columns = X.columns + else: + X_ = X + is_categorical = _check_categories(categorical_features, + X_)[0] + if is_categorical is None: + is_categorical = np.zeros(X_.shape[1], np.bool) + is_ordinal = np.zeros_like(is_categorical) + self.columns = np.arange(X.shape[1]) + + nfeatures = X_.shape[0] + + if (not isinstance(max_features, int) or + (max_features > nfeatures or max_features < 1)): + raise AttributeError('max_features must be' + ' smaller than %d and larger than 0' % + (nfeatures + 1)) + + if (not isinstance(min_features, int) or + (min_features > nfeatures or min_features < 1)): + raise AttributeError('min_features must be' + ' smaller than %d and larger than 0' + % (nfeatures + 1)) + + if max_features < min_features: + raise AttributeError('min_features must be <= max_features') + + self.min_features, self.max_features = min_features, max_features + + # make a mapping from the column info to columns in + # implied design matrix + + self.column_info_ = _get_column_info(X, + self.columns, + is_categorical, + is_ordinal) + self.column_map_ = {} + idx = 0 + for col in self.columns: + l = self.column_info_[col].columns + self.column_map_[col] = range(idx, idx + + len(l)) + idx += len(l) + if (custom_feature_names is not None + and len(custom_feature_names) != nfeatures): + raise ValueError('If custom_feature_names is not None, ' + 'the number of elements in custom_feature_names ' + 'must equal %d the number of columns in X.' % idx) + if custom_feature_names is not None: + # recompute the Column info using custom_feature_names + for i, col in enumerate(self.columns): + cur_col = self.column_info_[col] + new_name = custom_feature_names[i] + old_name = cur_col.name + self.column_info_[col] = Column(col, + new_name, + col.is_categorical, + col.is_ordinal, + tuple([n.replace(old_name, + new_name) for n in col.columns]), + col.encoder) + + self._have_already_run = False + if fixed_features is not None: + self.fixed_features = set([self.column_info_[f].idx for f in fixed_features]) + else: + self.fixed_features = set([]) + + def candidate_states(self, state): + """ + Produce candidates for fitting. + + Parameters + ---------- + + state: ignored + + Returns + ------- + candidates: iterator + A generator of (indices, label) where indices + are columns of X and label is a name for the + given model. The iterator cycles through + all combinations of columns of nfeature total + of size ranging between min_features and max_features. + If appropriate, restricts combinations to include + a set of fixed features. + Models are labeled with a tuple of the feature names. + The names of the columns default to strings of integers + from range(nfeatures). + + """ + + if not self._have_already_run: + self._have_already_run = True # maybe could be done with a StopIteration on candidates? + def chain_(i): + return (c for c in combinations(self.columns, r=i) + if self.fixed_features.issubset(c)) + + candidates = chain.from_iterable(chain_(i) for i in + range(self.min_features, + self.max_features+1)) + return candidates + + def check_finished(self, + results, + best_state, + batch_results): + """ + Check if we should continue or not. + For exhaustive search we stop because + all models are fit in a single batch. + """ + return best_state, results[best_state]['avg_score'], True + + +class StepCandidates(MinMaxCandidates): + + def __init__(self, + X, + direction='forward', + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None): + """ + Parameters + ---------- + X: {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + direction: str + One of ['forward', 'backward', 'both'] + min_features: int (default: 1) + Minumum number of features to select + max_features: int (default: 1) + Maximum number of features to select + fixed_features: column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names: None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features: array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + """ + + self.direction = direction + MinMaxCandidates.__init__(self, + X, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + def candidate_states(self, state): + """ + Produce candidates for fitting. + For stepwise search this depends on the direction. + + If 'forward', all columns not in the current state + are added (maintaining an upper limit on the number of columns + at `self.max_features`). + + If 'backward', all columns not in the current state + are dropped (maintaining a lower limit on the number of columns + at `self.min_features`). + + All candidates include `self.fixed_features` if any. + + Parameters + ---------- + + state: ignored + + Returns + ------- + candidates: iterator + A generator of (indices, label) where indices + are columns of X and label is a name for the + given model. The iterator cycles through + all combinations of columns of nfeature total + of size ranging between min_features and max_features. + If appropriate, restricts combinations to include + a set of fixed features. + Models are labeled with a tuple of the feature names. + The names of the columns default to strings of integers + from range(nfeatures). + + """ + + state = set(state) + if len(state) < self.max_features: # union + forward = (tuple(sorted(state | set([c]))) for c in self.columns if (c not in state and + self.fixed_features.issubset(state | set([c])))) + else: + forward = None + + if len(state) > self.min_features: # symmetric difference + backward = (tuple(sorted(state ^ set([c]))) for c in self.columns if (c in state and + self.fixed_features.issubset(state ^ set([c])))) + else: + backward = None + + if self.direction == 'forward': + return forward + elif self.direction == 'backward': + return backward + else: + return chain.from_iterable([forward, backward]) + + def check_finished(self, + results, + best_state, + batch_results): + """ + Check if we should continue or not. + + For stepwise search we stop if we cannot improve + over our current best score. + + """ + batch_best_score = -np.inf + batch_best_state = None + + for state in batch_results: + if batch_results[state]['avg_score'] > batch_best_score: + batch_best_score = batch_results[state]['avg_score'] + batch_best_state = state + + finished = batch_best_score <= results[best_state]['avg_score'] + return batch_best_state, batch_best_score, finished + + def validate(self, + current_state, + proposed_state): + """ + Determine if `proposed_state` + is a valid transition from `current_state`. + + Can be used in subclasses to enforce hierarchy or + other properties of the model. + + Parameters + ---------- + + state: object + Current state of the selection procedure. + + proposed_state: object + Candidate state of the selection procedure. + + Returns + ------- + + valid: bool + Is this a valid transition? + """ + + return True + +def min_max(X, + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None, + parsimonious=True): + """ + Parameters + ---------- + X: {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + min_features: int (default: 1) + Minumum number of features to select + max_features: int (default: 1) + Maximum number of features to select + fixed_features: column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names: None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features: array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + parsimonious: bool + If True, use the 1sd rule: among the shortest models + within one standard deviation of the best score + pick the one with the best average score. + + Returns + ------- + + initial_state: tuple + (column_names, feature_idx) + + state_generator: callable + Object that proposes candidates + based on current state. Takes a single + argument `state` + + build_submodel: callable + Candidate generator that enumerate + all valid subsets of columns. + + check_finished: callable + Check whether to stop. Takes two arguments: + `best_result` a dict with keys ['scores', 'avg_score']; + and `state`. + + """ + + min_max = MinMaxCandidates(X, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + # if any categorical features or an intercept + # is included then we must + # create a new design matrix + + build_submodel = partial(_build_submodel, min_max.column_info_) + + if min_max.fixed_features: + initial_features = sorted(min_max.fixed_features) + else: + initial_features = range(min_max.min_features) + initial_state = tuple(initial_features) + + if not parsimonious: + _postprocess = _postprocess_best + else: + _postprocess = _postprocess_best_1sd + + return Strategy(initial_state, + min_max.candidate_states, + build_submodel, + min_max.check_finished, + _postprocess) + +def step(X, + direction='forward', + min_features=1, + max_features=1, + random_state=0, + fixed_features=None, + initial_features=None, + custom_feature_names=None, + categorical_features=None, + parsimonious=True): + """ + Parameters + ---------- + X: {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + direction: str + One of ['forward', 'backward', 'both'] + min_features: int (default: 1) + Minumum number of features to select + max_features: int (default: 1) + Maximum number of features to select + fixed_features: column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + initial_features: column identifiers, default=None + Subset of features to be used to initialize when direction + is `both`. If None defaults to behavior of `forward`. + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + custom_feature_names: None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features: array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + parsimonious: bool + If True, use the 1sd rule: among the shortest models + within one standard deviation of the best score + pick the one with the best average score. + + Returns + ------- + + initial_state: tuple + (column_names, feature_idx) + + state_generator: callable + Object that proposes candidates + based on current state. Takes a single + argument `state` + + build_submodel: callable + Candidate generator that enumerate + all valid subsets of columns. + + check_finished: callable + Check whether to stop. Takes two arguments: + `best_result` a dict with keys ['scores', 'avg_score']; + and `state`. + + """ + + step = StepCandidates(X, + direction, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + # if any categorical features or an intercept + # is included then we must + # create a new design matrix + + build_submodel = partial(_build_submodel, step.column_info_) + + # pick an initial state + + if direction in ['forward', 'both']: + if step.fixed_features: + forward_features = sorted(step.fixed_features) + else: + forward_features = range(step.min_features) + if direction == 'forward': + initial_features = forward_features + else: + if initial_features is None: + initial_features = forward_features + elif direction == 'backward': + if initial_features is None: + random_state = check_random_state(random_state) + initial_features = sorted(random_state.choice([col for col in step.column_info_], + step.max_features, + replace=False)) + initial_state = tuple(initial_features) + + if len(initial_features) > step.max_features: + raise ValueError('initial_features should be of length <= %d' % step.max_features) + if len(initial_features) < step.min_features: + raise ValueError('initial_features should be of length >= %d' % step.min_features) + if not step.fixed_features.issubset(initial_features): + raise ValueError('initial_features should contain %s' % str(step.fixed_features)) + + if not parsimonious: + _postprocess = _postprocess_best + else: + _postprocess = _postprocess_best_1sd + + return Strategy(initial_state, + step.candidate_states, + build_submodel, + step.check_finished, + _postprocess) + + +# private functions + + +def _build_submodel(column_info, X, cols): + return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) + + +def _postprocess_best(results): + """ + Find the best state from `results` + based on `avg_score`. + + Return best state and results + """ + + best_state = None + best_score = -np.inf + + for state, result in results.items(): + if result['avg_score'] > best_score: + best_state = state + best_score = result['avg_score'] + + return best_state, results + +def _postprocess_best_1sd(results): + """ + Find the best state from `results` + based on `avg_score`. + + Find models satisfying the 1sd rule + and choose the state with best score + among the smallest such states. + + Return best state and results + + Models are compared by length of state + """ + + best_state = None + best_score = -np.inf + + for state, result in results.items(): + if result['avg_score'] > best_score: + best_state = state + best_score = result['avg_score'] + + states_1sd = [] + + for state, result in results.items(): + if len(state) >= len(best_state): + continue + scores = result['scores'] + _limit = (result['avg_score'] + + np.nanstd(scores) / np.sqrt(scores.shape[0])) + if _limit >= best_score: + states_1sd.append(state) + + shortest_1sd = np.inf + + for state in states_1sd: + if len(state) < shortest_1sd: + shortest_1sd = len(state) + + best_state_1sd = None + best_score_1sd = -np.inf + + for state in states_1sd: + if ((len(state) == shortest_1sd) + and (results[state]['avg_score'] <= + best_score_1sd)): + best_state_1sd = state + best_score_1sd = result['avg_score'][state] + + if best_state_1sd: + return best_state_1sd, results + else: + return best_state, results diff --git a/mlxtend/feature_selection/tests/test_generic_selector.py b/mlxtend/feature_selection/tests/test_generic_selector.py index e793ac3d8..1cf2eb1e5 100644 --- a/mlxtend/feature_selection/tests/test_generic_selector.py +++ b/mlxtend/feature_selection/tests/test_generic_selector.py @@ -4,9 +4,9 @@ import numpy as np from sklearn.linear_model import LinearRegression -from mlxtend.feature_selection.generic_selector import (min_max, - step, - FeatureSelector) +from mlxtend.feature_selection.generic_selector import FeatureSelector +from mlxtend.feature_selection.strategy import min_max, step + have_pandas = True try: From 4482a65c069b9111b754035b371902f9d0db89e0 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Tue, 26 Oct 2021 12:53:42 -0700 Subject: [PATCH 11/14] rename min_max to exhaustive --- mlxtend/feature_selection/generic_selector.py | 8 +- mlxtend/feature_selection/strategy.py | 76 +++++++------------ .../tests/test_generic_selector.py | 68 ++++++++--------- 3 files changed, 66 insertions(+), 86 deletions(-) diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py index 71ca15e6b..cd2bdbb91 100644 --- a/mlxtend/feature_selection/generic_selector.py +++ b/mlxtend/feature_selection/generic_selector.py @@ -1,15 +1,13 @@ # Sebastian Raschka 2014-2020 # mlxtend Machine Learning Library Extensions # -# Algorithm for sequential feature selection. +# Algorithm for generic feature selection. # Author: Sebastian Raschka # # License: BSD 3 clause - -# Modified by Jonathan Taylor 2021 # -# Derives from sequential_feature_selector -# but allows custom model search +# Modified for generic search +# Jonathan Taylor 2021 import types import sys diff --git a/mlxtend/feature_selection/strategy.py b/mlxtend/feature_selection/strategy.py index c3d489271..b0fc9fb07 100644 --- a/mlxtend/feature_selection/strategy.py +++ b/mlxtend/feature_selection/strategy.py @@ -202,7 +202,16 @@ def check_finished(self, For exhaustive search we stop because all models are fit in a single batch. """ - return best_state, results[best_state]['avg_score'], True + batch_best_score = -np.inf + batch_best_state = None + + for state in batch_results: + if batch_results[state]['avg_score'] > batch_best_score: + batch_best_score = batch_results[state]['avg_score'] + batch_best_state = state + + return batch_best_state, batch_best_score, True + class StepCandidates(MinMaxCandidates): @@ -338,41 +347,14 @@ def check_finished(self, finished = batch_best_score <= results[best_state]['avg_score'] return batch_best_state, batch_best_score, finished - def validate(self, - current_state, - proposed_state): - """ - Determine if `proposed_state` - is a valid transition from `current_state`. - - Can be used in subclasses to enforce hierarchy or - other properties of the model. - Parameters - ---------- - - state: object - Current state of the selection procedure. - - proposed_state: object - Candidate state of the selection procedure. - - Returns - ------- - - valid: bool - Is this a valid transition? - """ - - return True - -def min_max(X, - min_features=1, - max_features=1, - fixed_features=None, - custom_feature_names=None, - categorical_features=None, - parsimonious=True): +def exhaustive(X, + min_features=1, + max_features=1, + fixed_features=None, + custom_feature_names=None, + categorical_features=None, + parsimonious=True): """ Parameters ---------- @@ -432,23 +414,23 @@ def min_max(X, """ - min_max = MinMaxCandidates(X, - min_features, - max_features, - fixed_features, - custom_feature_names, - categorical_features) + strategy = MinMaxCandidates(X, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) # if any categorical features or an intercept # is included then we must # create a new design matrix - build_submodel = partial(_build_submodel, min_max.column_info_) + build_submodel = partial(_build_submodel, strategy.column_info_) - if min_max.fixed_features: - initial_features = sorted(min_max.fixed_features) + if strategy.fixed_features: + initial_features = sorted(strategy.fixed_features) else: - initial_features = range(min_max.min_features) + initial_features = range(strategy.min_features) initial_state = tuple(initial_features) if not parsimonious: @@ -457,9 +439,9 @@ def min_max(X, _postprocess = _postprocess_best_1sd return Strategy(initial_state, - min_max.candidate_states, + strategy.candidate_states, build_submodel, - min_max.check_finished, + strategy.check_finished, _postprocess) def step(X, diff --git a/mlxtend/feature_selection/tests/test_generic_selector.py b/mlxtend/feature_selection/tests/test_generic_selector.py index 1cf2eb1e5..a5fde2532 100644 --- a/mlxtend/feature_selection/tests/test_generic_selector.py +++ b/mlxtend/feature_selection/tests/test_generic_selector.py @@ -5,7 +5,7 @@ import numpy as np from sklearn.linear_model import LinearRegression from mlxtend.feature_selection.generic_selector import FeatureSelector -from mlxtend.feature_selection.strategy import min_max, step +from mlxtend.feature_selection.strategy import exhaustive, step have_pandas = True @@ -20,47 +20,47 @@ def test_exhaustive_selector(): X = np.random.standard_normal((n, p)) Y = np.random.standard_normal(n) - strategy = min_max(X, - max_features=4, - fixed_features=[2,3]) + strategy = exhaustive(X, + max_features=4, + fixed_features=[2,3]) - min_max_selector = FeatureSelector(LinearRegression(), - strategy) + exhaustive_selector = FeatureSelector(LinearRegression(), + strategy) - min_max_selector.fit(X, Y) + exhaustive_selector.fit(X, Y) - strategy = min_max(X, - max_features=4) + strategy = exhaustive(X, + max_features=4) - min_max_selector = FeatureSelector(LinearRegression(), - strategy) + exhaustive_selector = FeatureSelector(LinearRegression(), + strategy) - min_max_selector.fit(X, Y) - min_max_selector.transform(X) - min_max_selector.fit_transform(X, Y) + exhaustive_selector.fit(X, Y) + exhaustive_selector.transform(X) + exhaustive_selector.fit_transform(X, Y) # test CV - strategy = min_max(X, - max_features=4) + strategy = exhaustive(X, + max_features=4) - min_max_selector = FeatureSelector(LinearRegression(), - strategy, - cv=3) + exhaustive_selector = FeatureSelector(LinearRegression(), + strategy, + cv=3) # test CV, verbose - strategy = min_max(X, - max_features=4) + strategy = exhaustive(X, + max_features=4) for cv, verbose in product([None, 3], [0,1,2]): - min_max_selector = FeatureSelector(LinearRegression(), - strategy, - cv=3, - verbose=verbose) + exhaustive_selector = FeatureSelector(LinearRegression(), + strategy, + cv=3, + verbose=verbose) - min_max_selector.fit(X, Y) - print(min_max_selector.best_state_) + exhaustive_selector.fit(X, Y) + print(exhaustive_selector.best_state_) def test_exhaustive_categorical(): @@ -70,15 +70,15 @@ def test_exhaustive_categorical(): Y = np.random.standard_normal(n) categorical_features = [True] + [False]*4 - strategy = min_max(X, - max_features=4, - fixed_features=[2,3], - categorical_features=categorical_features) + strategy = exhaustive(X, + max_features=4, + fixed_features=[2,3], + categorical_features=categorical_features) - min_max_selector = FeatureSelector(LinearRegression(), - strategy) + exhaustive_selector = FeatureSelector(LinearRegression(), + strategy) - min_max_selector.fit(X, Y) + exhaustive_selector.fit(X, Y) def test_step_categorical(): From d980387c2ce15d9cc6b6dab245d074f71b14d73b Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Tue, 26 Oct 2021 14:40:42 -0700 Subject: [PATCH 12/14] added comparison to step for Boston data using neg_AIC to select; can have a model with no features (design==0) --- mlxtend/feature_selection/generic_selector.py | 83 ++++--- mlxtend/feature_selection/strategy.py | 130 ++++++----- .../tests/test_generic_selector.py | 212 +++++++++++++++++- 3 files changed, 327 insertions(+), 98 deletions(-) diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py index cd2bdbb91..aeaed93ed 100644 --- a/mlxtend/feature_selection/generic_selector.py +++ b/mlxtend/feature_selection/generic_selector.py @@ -1,13 +1,15 @@ # Sebastian Raschka 2014-2020 # mlxtend Machine Learning Library Extensions # -# Algorithm for generic feature selection. +# Algorithm for sequential feature selection. # Author: Sebastian Raschka # # License: BSD 3 clause + +# Modified by Jonathan Taylor 2021 # -# Modified for generic search -# Jonathan Taylor 2021 +# Derives from sequential_feature_selector +# but allows custom model search import types import sys @@ -212,7 +214,7 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): self.interrupted_ = False self.finished_ = False - results_ = {} + results_ = [] # unpack the strategy @@ -238,39 +240,42 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): # keep a running track of the best state self.path_ = [deepcopy(_state)] - self.best_state_ = _state - self.best_score_ = np.nanmean(_scores) + iteration = 0 + cur = best = (_state, iteration, _scores) self.update_results_check(results_, - {_state: {'scores': _scores, - 'avg_score': np.nanmean(_scores)}}, + cur, + [(_state, iteration, _scores)], check_finished) - + iteration += 1 try: while not self.finished_: - batch_results = self._batch(_state, - candidate_states(_state), + batch_results = self._batch(iteration, + cur[0], + candidate_states(cur[0]), build_submodel, X, y, groups=groups, **fit_params) - - _state, _score, self.finished_ = self.update_results_check(results_, - batch_results, - check_finished) - - self.path_.append(deepcopy(_state)) + iteration += 1 + cur, best_, self.finished_ = self.update_results_check(results_, + best, + batch_results, + check_finished) + if best_: + best = best_ + self.path_.append(deepcopy(cur)) if self._TESTING_INTERRUPT_MODE: raise KeyboardInterrupt - except KeyboardInterrupt: self.interrupted_ = True sys.stderr.write('\nSTOPPING EARLY DUE TO KEYBOARD INTERRUPT...') self.selected_state_, self.results_ = postprocess(results_) + self.fitted = True return self @@ -371,7 +376,8 @@ def _calc_confidence(ary, confidence=0.95): # private methods def _batch(self, - state, + iteration, + cur_state, candidates, build_submodel, X, @@ -379,7 +385,7 @@ def _batch(self, groups=None, **fit_params): - results = {} + results = [] if candidates is not None: @@ -401,8 +407,7 @@ def _batch(self, for state in candidates) for state, scores in work: - results[state] = {'scores': scores, - 'avg_score': np.nanmean(scores)} + results.append((state, iteration, scores)) return results @@ -412,6 +417,7 @@ def _check_fitted(self): def update_results_check(self, results, + best, batch_results, check_finished): """ @@ -428,6 +434,9 @@ def update_results_check(self, dictionaries having keys `scores`, `avg_scores`. + best : (state, score) + Current best state and score. + batch_results: dict Dictionary of results from a batch fit. Keys are tate with values @@ -454,28 +463,30 @@ def update_results_check(self, """ - finished = batch_results == {} + finished = batch_results == [] if not finished: - results.update(batch_results) - (cur_state, - cur_score, + (cur, finished) = check_finished(results, - self.best_state_, + best, batch_results) - if cur_score > self.best_score_: - self.best_state_ = cur_state - self.best_score_ = cur_score - return cur_state, cur_score, finished - else: - return None, None, True + results.extend(batch_results) + if cur[2] is not None and np.nanmean(cur[2]) > np.nanmean(best[2]): + best = cur + return (cur, + best, + finished) + else: + return ((None, None, None), + (None, None, None), + True) -# private functions +# private functions def _calc_score(estimator, scorer, @@ -489,7 +500,7 @@ def _calc_score(estimator, **fit_params): X_state = build_submodel(X, state) - + if cv: scores = cross_val_score(estimator, X_state, @@ -503,7 +514,7 @@ def _calc_score(estimator, else: estimator.fit(X_state, y, - **fit_params) + **fit_params) scores = np.array([scorer(estimator, X_state, y)]) diff --git a/mlxtend/feature_selection/strategy.py b/mlxtend/feature_selection/strategy.py index b0fc9fb07..f00035215 100644 --- a/mlxtend/feature_selection/strategy.py +++ b/mlxtend/feature_selection/strategy.py @@ -102,15 +102,15 @@ def __init__(self, nfeatures = X_.shape[0] if (not isinstance(max_features, int) or - (max_features > nfeatures or max_features < 1)): + (max_features > nfeatures or max_features < 0)): raise AttributeError('max_features must be' - ' smaller than %d and larger than 0' % + ' <= than %d and >= 0' % (nfeatures + 1)) if (not isinstance(min_features, int) or - (min_features > nfeatures or min_features < 1)): + (min_features > nfeatures or min_features < 0)): raise AttributeError('min_features must be' - ' smaller than %d and larger than 0' + ' <= %d and >= 0' % (nfeatures + 1)) if max_features < min_features: @@ -151,7 +151,6 @@ def __init__(self, new_name) for n in col.columns]), col.encoder) - self._have_already_run = False if fixed_features is not None: self.fixed_features = set([self.column_info_[f].idx for f in fixed_features]) else: @@ -182,36 +181,34 @@ def candidate_states(self, state): """ - if not self._have_already_run: - self._have_already_run = True # maybe could be done with a StopIteration on candidates? - def chain_(i): - return (c for c in combinations(self.columns, r=i) - if self.fixed_features.issubset(c)) - - candidates = chain.from_iterable(chain_(i) for i in - range(self.min_features, - self.max_features+1)) - return candidates + def chain_(i): + return (c for c in combinations(self.columns, r=i) + if self.fixed_features.issubset(c)) + + candidates = chain.from_iterable(chain_(i) for i in + range(self.min_features, + self.max_features+1)) + return candidates def check_finished(self, results, - best_state, + best, batch_results): """ Check if we should continue or not. For exhaustive search we stop because all models are fit in a single batch. """ + new_best = (None, None, None) batch_best_score = -np.inf - batch_best_state = None - - for state in batch_results: - if batch_results[state]['avg_score'] > batch_best_score: - batch_best_score = batch_results[state]['avg_score'] - batch_best_state = state - - return batch_best_state, batch_best_score, True + + for (state, iteration, scores) in batch_results: + avg_score = np.nanmean(scores) + if avg_score > batch_best_score: + new_best = (state, iteration, scores) + batch_best_score = np.nanmean(scores) + return new_best, True class StepCandidates(MinMaxCandidates): @@ -310,13 +307,13 @@ def candidate_states(self, state): forward = (tuple(sorted(state | set([c]))) for c in self.columns if (c not in state and self.fixed_features.issubset(state | set([c])))) else: - forward = None + forward = [] if len(state) > self.min_features: # symmetric difference backward = (tuple(sorted(state ^ set([c]))) for c in self.columns if (c in state and self.fixed_features.issubset(state ^ set([c])))) else: - backward = None + backward = [] if self.direction == 'forward': return forward @@ -327,7 +324,7 @@ def candidate_states(self, state): def check_finished(self, results, - best_state, + best, batch_results): """ Check if we should continue or not. @@ -336,17 +333,17 @@ def check_finished(self, over our current best score. """ + new_best = (None, None, None) batch_best_score = -np.inf - batch_best_state = None - for state in batch_results: - if batch_results[state]['avg_score'] > batch_best_score: - batch_best_score = batch_results[state]['avg_score'] - batch_best_state = state + for state, iteration, scores in batch_results: + avg_score = np.nanmean(scores) + if avg_score > batch_best_score: + new_best = (state, iteration, scores) + batch_best_score = avg_score - finished = batch_best_score <= results[best_state]['avg_score'] - return batch_best_state, batch_best_score, finished - + finished = batch_best_score <= np.nanmean(best[2]) + return new_best, finished def exhaustive(X, min_features=1, @@ -536,11 +533,15 @@ def step(X, # pick an initial state + random_state = check_random_state(random_state) + if direction in ['forward', 'both']: if step.fixed_features: forward_features = sorted(step.fixed_features) else: - forward_features = range(step.min_features) + forward_features = sorted(random_state.choice([col for col in step.column_info_], + step.min_features, + replace=False)) if direction == 'forward': initial_features = forward_features else: @@ -548,7 +549,6 @@ def step(X, initial_features = forward_features elif direction == 'backward': if initial_features is None: - random_state = check_random_state(random_state) initial_features = sorted(random_state.choice([col for col in step.column_info_], step.max_features, replace=False)) @@ -577,8 +577,11 @@ def step(X, def _build_submodel(column_info, X, cols): - return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) - + if cols: + return np.column_stack([column_info[col].get_columns(X, fit=True)[0] for col in cols]) + else: + return np.zeros((X.shape[0], 1)) + def _postprocess_best(results): """ @@ -591,17 +594,21 @@ def _postprocess_best(results): best_state = None best_score = -np.inf - for state, result in results.items(): - if result['avg_score'] > best_score: - best_state = state - best_score = result['avg_score'] + new_results = {} + for (state, iteration, scores) in results: + new_state = tuple(state) # [v.name for v in state]) + avg_score = np.nanmean(scores) + if avg_score > best_score: + best_state = new_state + best_score = avg_score + new_results[new_state] = avg_score + return best_state, new_results - return best_state, results def _postprocess_best_1sd(results): """ Find the best state from `results` - based on `avg_score`. + based on np.nanmean(scores) Find models satisfying the 1sd rule and choose the state with best score @@ -615,39 +622,46 @@ def _postprocess_best_1sd(results): best_state = None best_score = -np.inf - for state, result in results.items(): - if result['avg_score'] > best_score: + for state, iteration, scores in results: + avg_score = np.nanmean(scores) + if avg_score > best_score: best_state = state - best_score = result['avg_score'] + best_score = avg_score states_1sd = [] - for state, result in results.items(): + for (state, iteration, scores) in results: if len(state) >= len(best_state): continue - scores = result['scores'] - _limit = (result['avg_score'] + + _limit = (np.nanmean(scores) + np.nanstd(scores) / np.sqrt(scores.shape[0])) if _limit >= best_score: - states_1sd.append(state) + states_1sd.append((state, iteration, scores)) shortest_1sd = np.inf - for state in states_1sd: + for (state, iteration, scores) in states_1sd: if len(state) < shortest_1sd: shortest_1sd = len(state) best_state_1sd = None best_score_1sd = -np.inf - for state in states_1sd: + for (state, iteration, scores) in states_1sd: + avg_score = np.nanmean(scores) if ((len(state) == shortest_1sd) - and (results[state]['avg_score'] <= + and (avg_score <= best_score_1sd)): best_state_1sd = state - best_score_1sd = result['avg_score'][state] + best_score_1sd = avg_score + new_results = {} + for (state, iteration, scores) in results: + new_state = tuple(state) #[v.name for v in state]) + new_results[new_state] = np.nanmean(scores) if best_state_1sd: - return best_state_1sd, results + best_state_1sd = tuple([v.name for v in best_state_1sd]) + return best_state_1sd, new_results else: - return best_state, results + best_state = tuple(best_state) # [v.name for v in best_state]) + return best_state, new_results diff --git a/mlxtend/feature_selection/tests/test_generic_selector.py b/mlxtend/feature_selection/tests/test_generic_selector.py index a5fde2532..46d18d0be 100644 --- a/mlxtend/feature_selection/tests/test_generic_selector.py +++ b/mlxtend/feature_selection/tests/test_generic_selector.py @@ -42,7 +42,7 @@ def test_exhaustive_selector(): # test CV strategy = exhaustive(X, - max_features=4) + max_features=5) exhaustive_selector = FeatureSelector(LinearRegression(), strategy, @@ -50,17 +50,18 @@ def test_exhaustive_selector(): # test CV, verbose strategy = exhaustive(X, - max_features=4) + max_features=3) for cv, verbose in product([None, 3], [0,1,2]): + exhaustive_selector = FeatureSelector(LinearRegression(), strategy, - cv=3, + cv=cv, verbose=verbose) exhaustive_selector.fit(X, Y) - print(exhaustive_selector.best_state_) + print(cv, verbose, exhaustive_selector.selected_state_) def test_exhaustive_categorical(): @@ -98,6 +99,41 @@ def test_step_categorical(): strategy) step_selector.fit(X, Y) +def test_step_scoring(): + + n, p = 100, 10 + + def AIC(estimator, X, Y): + Yhat = estimator.predict(X) + return 0.5 * ((Y - Yhat)**2).sum() + 2 * X.shape[1] + + X = np.random.standard_normal((n, p)) + X[:,0] = np.random.choice(range(5), (n,), replace=True) + Y = np.random.standard_normal(n) + + categorical_features = [True] + [False]*9 + strategy = step(X, + max_features=4, + fixed_features=[2,3], + categorical_features=categorical_features) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + scoring='neg_mean_squared_error') + step_selector.fit(X, Y) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + scoring='neg_mean_squared_error', + cv=None) + step_selector.fit(X, Y) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + scoring=AIC, + cv=None) + step_selector.fit(X, Y) + def test_step_bigger(): n, p = 100, 20 @@ -141,3 +177,171 @@ def test_pandas1(): step_selector.fit(D, Y) print(step_selector.path_) + +def neg_AIC(linmod, X, Y): + """ + Negative AIC for linear regression model + """ + n, p = X.shape + Yhat = linmod.predict(X) + sigma_MLE = np.linalg.norm(Y - Yhat) / np.sqrt(n) + # adding 2 -- one for sigma^2, one for intercept fit by LinearRegression + return -(n * np.log(2 * np.pi * sigma_MLE**2) + n + 2 * (p + 2)) + +def test_boston_forward(): + """Ran the following R cell + ```{R} + library(MASS) + data(Boston) + M=step(glm(medv ~ 1, data=Boston), list(upper=glm(medv ~ ., data=Boston)), direction='forward', trace=FALSE) + print(AIC(M)) + names(coef(M)[2:12]) + ``` + + Output: + + [1] 3023.726 + [1] "lstat" "rm" "ptratio" "dis" "nox" "chas" "black" + [8] "zn" "crim" "rad" "tax" + """ + + try: + import statsmodels.api as sm + except ImportError as e: + warnings.warn('import of statsmodels failed') + return + + selected_R = ["lstat", "rm", "ptratio", "dis", + "nox", "chas", "black", + "zn", "crim", "rad", "tax"] + + Boston = sm.datasets.get_rdataset('Boston', package='MASS').data + D = Boston.drop('medv', axis=1) + X = D.values + Y = Boston['medv'] + + strategy = step(X, + max_features=X.shape[1], + min_features=0, + direction='forward', + parsimonious=False) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + scoring=neg_AIC, + cv=None) + step_selector.fit(X, Y) + + selected_vars = [D.columns[j] for j in step_selector.selected_state_] + + Xsel = X[:,list(step_selector.selected_state_)] + selected_model = LinearRegression().fit(Xsel, Y) + + assert(sorted(selected_vars) == sorted(selected_R)) + assert(np.fabs(neg_AIC(selected_model, Xsel, Y) + 3023.726) < 0.01) + +def test_boston_both(): + """Ran the following R cell + ```{R} + %%R + library(MASS) + data(Boston) + M=step(glm(medv ~ ., data=Boston), list(upper=glm(medv ~ 1, data=Boston)), direction='both', trace=FALSE) + print(AIC(M)) + names(coef(M)[2:12]) + ``` + + Output: + + [1] 3023.726 + [1] "crim" "zn" "chas" "nox" "rm" "dis" "rad" + [8] "tax" "ptratio" "black" "lstat" + + """ + + try: + import statsmodels.api as sm + except ImportError as e: + warnings.warn('import of statsmodels failed') + return + + selected_R = ["crim", "zn", "chas", "nox", "rm", "dis", "rad", + "tax", "ptratio", "black", "lstat"] + + Boston = sm.datasets.get_rdataset('Boston', package='MASS').data + D = Boston.drop('medv', axis=1) + X = D.values + Y = Boston['medv'] + + strategy = step(X, + max_features=X.shape[1], + min_features=0, + direction='both', + parsimonious=False) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + scoring=neg_AIC, + cv=None) + step_selector.fit(X, Y) + + selected_vars = [D.columns[j] for j in step_selector.selected_state_] + + Xsel = X[:,list(step_selector.selected_state_)] + selected_model = LinearRegression().fit(Xsel, Y) + + assert(sorted(selected_vars) == sorted(selected_R)) + assert(np.fabs(neg_AIC(selected_model, Xsel, Y) + 3023.726) < 0.01) + +def test_boston_back(): + """Ran the following R cell + ```{R} + %%R + library(MASS) + data(Boston) + M=step(glm(medv ~ ., data=Boston), list(upper=glm(medv ~ 1, data=Boston)), direction='back', trace=FALSE) + print(AIC(M)) + names(coef(M)[2:12]) + ``` + + Output: + + [1] 3023.726 + [1] "crim" "zn" "chas" "nox" "rm" "dis" "rad" + [8] "tax" "ptratio" "black" "lstat" + + """ + + try: + import statsmodels.api as sm + except ImportError as e: + warnings.warn('import of statsmodels failed') + return + + selected_R = ["crim", "zn", "chas", "nox", "rm", "dis", "rad", + "tax", "ptratio", "black", "lstat"] + + Boston = sm.datasets.get_rdataset('Boston', package='MASS').data + D = Boston.drop('medv', axis=1) + X = D.values + Y = Boston['medv'] + + strategy = step(X, + max_features=X.shape[1], + direction='backward', + parsimonious=False) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + scoring=neg_AIC, + cv=None) + step_selector.fit(X, Y) + + selected_vars = [D.columns[j] for j in step_selector.selected_state_] + + Xsel = X[:,list(step_selector.selected_state_)] + selected_model = LinearRegression().fit(Xsel, Y) + + assert(sorted(selected_vars) == sorted(selected_R)) + assert(np.fabs(neg_AIC(selected_model, Xsel, Y) + 3023.726) < 0.01) + From 2767ed8ed2bc8f8a858091e784067a19b1973f11 Mon Sep 17 00:00:00 2001 From: Jonathan Taylor Date: Thu, 28 Oct 2021 13:21:09 -0700 Subject: [PATCH 13/14] specializing stepwise to fixed number of steps, or first peak --- mlxtend/feature_selection/generic_selector.py | 12 +- mlxtend/feature_selection/strategy.py | 388 +++++++++++------- .../tests/test_generic_selector.py | 134 ++++-- 3 files changed, 354 insertions(+), 180 deletions(-) diff --git a/mlxtend/feature_selection/generic_selector.py b/mlxtend/feature_selection/generic_selector.py index aeaed93ed..3c82b1217 100644 --- a/mlxtend/feature_selection/generic_selector.py +++ b/mlxtend/feature_selection/generic_selector.py @@ -179,7 +179,7 @@ def set_params(self, **params): self._set_params('estimator', 'named_estimators', **params) return self - def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): + def fit(self, X, y, groups=None, **fit_params): """Perform feature selection and learn model from training data. Parameters @@ -193,10 +193,6 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): Target values. New in v 0.13.0: pandas DataFrames are now also accepted as argument for y. - custom_feature_names: None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) groups: array-like, with shape (n_samples,), optional Group labels for the samples used while splitting the dataset into train/test set. Passed to the fit method of the cross-validator. @@ -239,11 +235,12 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): # keep a running track of the best state - self.path_ = [deepcopy(_state)] iteration = 0 + self.path_ = [deepcopy((_state, iteration, _scores))] cur = best = (_state, iteration, _scores) self.update_results_check(results_, + self.path_, cur, [(_state, iteration, _scores)], check_finished) @@ -261,6 +258,7 @@ def fit(self, X, y, custom_feature_names=None, groups=None, **fit_params): **fit_params) iteration += 1 cur, best_, self.finished_ = self.update_results_check(results_, + self.path_, best, batch_results, check_finished) @@ -417,6 +415,7 @@ def _check_fitted(self): def update_results_check(self, results, + path, best, batch_results, check_finished): @@ -469,6 +468,7 @@ def update_results_check(self, (cur, finished) = check_finished(results, + path, best, batch_results) diff --git a/mlxtend/feature_selection/strategy.py b/mlxtend/feature_selection/strategy.py index f00035215..719247e60 100644 --- a/mlxtend/feature_selection/strategy.py +++ b/mlxtend/feature_selection/strategy.py @@ -99,7 +99,7 @@ def __init__(self, is_ordinal = np.zeros_like(is_categorical) self.columns = np.arange(X.shape[1]) - nfeatures = X_.shape[0] + nfeatures = X_.shape[1] if (not isinstance(max_features, int) or (max_features > nfeatures or max_features < 0)): @@ -192,6 +192,7 @@ def chain_(i): def check_finished(self, results, + path, best, batch_results): """ @@ -211,11 +212,11 @@ def check_finished(self, return new_best, True -class StepCandidates(MinMaxCandidates): +class Stepwise(MinMaxCandidates): def __init__(self, X, - direction='forward', + direction, min_features=1, max_features=1, fixed_features=None, @@ -258,6 +259,7 @@ def __init__(self, """ self.direction = direction + MinMaxCandidates.__init__(self, X, min_features, @@ -321,29 +323,195 @@ def candidate_states(self, state): return backward else: return chain.from_iterable([forward, backward]) - - def check_finished(self, - results, - best, - batch_results): + + @staticmethod + def first_peak(X, + direction='forward', + min_features=1, + max_features=1, + fixed_features=None, + initial_features=[], + custom_feature_names=None, + categorical_features=None, + parsimonious=True): """ - Check if we should continue or not. + Strategy that stops when no improvement + in score is possible. - For stepwise search we stop if we cannot improve - over our current best score. + Parameters + ---------- + X: {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + direction: str + One of ['forward', 'backward', 'both'] + min_features: int (default: 1) + Minumum number of features to select + max_features: int (default: 1) + Maximum number of features to select + fixed_features: column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + initial_features: column identifiers, default=[] + Subset of features to be used to initialize. + custom_feature_names: None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features: array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + parsimonious: bool + If True, use the 1sd rule: among the shortest models + within one standard deviation of the best score + pick the one with the best average score. + + Returns + ------- + + strategy : NamedTuple """ - new_best = (None, None, None) - batch_best_score = -np.inf - for state, iteration, scores in batch_results: - avg_score = np.nanmean(scores) - if avg_score > batch_best_score: - new_best = (state, iteration, scores) - batch_best_score = avg_score - - finished = batch_best_score <= np.nanmean(best[2]) - return new_best, finished + step = Stepwise(X, + direction, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + # if any categorical features or an intercept + # is included then we must + # create a new design matrix + + build_submodel = partial(_build_submodel, step.column_info_) + + # pick an initial state + + initial_state = tuple(initial_features) + + if not step.fixed_features.issubset(initial_features): + raise ValueError('initial_features should contain %s' % str(step.fixed_features)) + + if not parsimonious: + _postprocess = _postprocess_best + else: + _postprocess = _postprocess_best_1sd + + return Strategy(initial_state, + step.candidate_states, + build_submodel, + first_peak, + _postprocess) + + @staticmethod + def fixed_size(X, + model_size, + direction='forward', + min_features=1, + max_features=1, + fixed_features=None, + initial_features=[], + custom_feature_names=None, + categorical_features=None, + parsimonious=True): + """ + Strategy that stops first time + a given model size is reached. + + Parameters + ---------- + X: {array-like, sparse matrix}, shape = [n_samples, n_features] + Training vectors, where n_samples is the number of samples and + n_features is the number of features. + New in v 0.13.0: pandas DataFrames are now also accepted as + argument for X. + direction: str + One of ['forward', 'backward', 'both'] + min_features: int (default: 1) + Minumum number of features to select + max_features: int (default: 1) + Maximum number of features to select + fixed_features: column identifiers, default=None + Subset of features to keep. Stored as `self.columns[fixed_features]` + where `self.columns` will correspond to columns if X is a `pd.DataFrame` + or an array of integers if X is an `np.ndarray` + initial_features: column identifiers, default=[] + Subset of features to be used to initialize. + custom_feature_names: None or tuple (default: tuple) + Custom feature names for `self.k_feature_names` and + `self.subsets_[i]['feature_names']`. + (new in v 0.13.0) + categorical_features: array-like of {bool, int} of shape (n_features) + or shape (n_categorical_features,), default=None. + Indicates the categorical features. + + - None: no feature will be considered categorical. + - boolean array-like: boolean mask indicating categorical features. + - integer array-like: integer indices indicating categorical + features. + + For each categorical feature, there must be at most `max_bins` unique + categories, and each categorical value must be in [0, max_bins -1]. + + parsimonious: bool + If True, use the 1sd rule: among the shortest models + within one standard deviation of the best score + pick the one with the best average score. + + Returns + ------- + + strategy : NamedTuple + + """ + + step = Stepwise(X, + direction, + min_features, + max_features, + fixed_features, + custom_feature_names, + categorical_features) + + # if any categorical features or an intercept + # is included then we must + # create a new design matrix + + build_submodel = partial(_build_submodel, step.column_info_) + + # pick an initial state + + initial_state = tuple(initial_features) + + if not step.fixed_features.issubset(initial_features): + raise ValueError('initial_features should contain %s' % str(step.fixed_features)) + + if not parsimonious: + _postprocess = _postprocess_best + else: + _postprocess = _postprocess_best_1sd + + return Strategy(initial_state, + step.candidate_states, + build_submodel, + partial(fixed_size, model_size), + partial(_postprocess_fixed_size, model_size)) + + def exhaustive(X, min_features=1, @@ -441,136 +609,52 @@ def exhaustive(X, strategy.check_finished, _postprocess) -def step(X, - direction='forward', - min_features=1, - max_features=1, - random_state=0, - fixed_features=None, - initial_features=None, - custom_feature_names=None, - categorical_features=None, - parsimonious=True): +def first_peak(results, + path, + best, + batch_results): """ - Parameters - ---------- - X: {array-like, sparse matrix}, shape = [n_samples, n_features] - Training vectors, where n_samples is the number of samples and - n_features is the number of features. - New in v 0.13.0: pandas DataFrames are now also accepted as - argument for X. - direction: str - One of ['forward', 'backward', 'both'] - min_features: int (default: 1) - Minumum number of features to select - max_features: int (default: 1) - Maximum number of features to select - fixed_features: column identifiers, default=None - Subset of features to keep. Stored as `self.columns[fixed_features]` - where `self.columns` will correspond to columns if X is a `pd.DataFrame` - or an array of integers if X is an `np.ndarray` - initial_features: column identifiers, default=None - Subset of features to be used to initialize when direction - is `both`. If None defaults to behavior of `forward`. - where `self.columns` will correspond to columns if X is a `pd.DataFrame` - or an array of integers if X is an `np.ndarray` - custom_feature_names: None or tuple (default: tuple) - Custom feature names for `self.k_feature_names` and - `self.subsets_[i]['feature_names']`. - (new in v 0.13.0) - categorical_features: array-like of {bool, int} of shape (n_features) - or shape (n_categorical_features,), default=None. - Indicates the categorical features. + Check if we should continue or not. - - None: no feature will be considered categorical. - - boolean array-like: boolean mask indicating categorical features. - - integer array-like: integer indices indicating categorical - features. - - For each categorical feature, there must be at most `max_bins` unique - categories, and each categorical value must be in [0, max_bins -1]. - - parsimonious: bool - If True, use the 1sd rule: among the shortest models - within one standard deviation of the best score - pick the one with the best average score. - - Returns - ------- - - initial_state: tuple - (column_names, feature_idx) - - state_generator: callable - Object that proposes candidates - based on current state. Takes a single - argument `state` - - build_submodel: callable - Candidate generator that enumerate - all valid subsets of columns. - - check_finished: callable - Check whether to stop. Takes two arguments: - `best_result` a dict with keys ['scores', 'avg_score']; - and `state`. + For first_peak search we stop if we cannot improve + over our current best score. """ + new_best = (None, None, None) + batch_best_score = -np.inf - step = StepCandidates(X, - direction, - min_features, - max_features, - fixed_features, - custom_feature_names, - categorical_features) - - # if any categorical features or an intercept - # is included then we must - # create a new design matrix - - build_submodel = partial(_build_submodel, step.column_info_) - - # pick an initial state - - random_state = check_random_state(random_state) + for state, iteration, scores in batch_results: + avg_score = np.nanmean(scores) + if avg_score > batch_best_score: + new_best = (state, iteration, scores) + batch_best_score = avg_score + + any_better = batch_best_score > np.nanmean(best[2]) + return new_best, not any_better + +def fixed_size(model_size, + results, + path, + best, + batch_results): + """ + Check if we should continue or not. - if direction in ['forward', 'both']: - if step.fixed_features: - forward_features = sorted(step.fixed_features) - else: - forward_features = sorted(random_state.choice([col for col in step.column_info_], - step.min_features, - replace=False)) - if direction == 'forward': - initial_features = forward_features - else: - if initial_features is None: - initial_features = forward_features - elif direction == 'backward': - if initial_features is None: - initial_features = sorted(random_state.choice([col for col in step.column_info_], - step.max_features, - replace=False)) - initial_state = tuple(initial_features) + For first_peak search we stop if we cannot improve + over our current best score. - if len(initial_features) > step.max_features: - raise ValueError('initial_features should be of length <= %d' % step.max_features) - if len(initial_features) < step.min_features: - raise ValueError('initial_features should be of length >= %d' % step.min_features) - if not step.fixed_features.issubset(initial_features): - raise ValueError('initial_features should contain %s' % str(step.fixed_features)) + """ + new_best = (None, None, None) + batch_best_score = -np.inf - if not parsimonious: - _postprocess = _postprocess_best - else: - _postprocess = _postprocess_best_1sd + for state, iteration, scores in batch_results: + avg_score = np.nanmean(scores) + if avg_score > batch_best_score: + new_best = (state, iteration, scores) + batch_best_score = avg_score - return Strategy(initial_state, - step.candidate_states, - build_submodel, - step.check_finished, - _postprocess) + any_better = batch_best_score > np.nanmean(best[2]) + return new_best, len(new_best[0]) == model_size # private functions @@ -582,6 +666,26 @@ def _build_submodel(column_info, X, cols): else: return np.zeros((X.shape[0], 1)) +def _postprocess_fixed_size(model_size, results): + """ + Find the best state from `results` + based on `avg_score`. + + Return best state and results + """ + + best_state = None + best_score = -np.inf + + new_results = {} + for (state, iteration, scores) in results: + new_state = tuple(state) # [v.name for v in state]) + avg_score = np.nanmean(scores) + if avg_score > best_score and len(new_state) == model_size: + best_state = new_state + best_score = avg_score + new_results[new_state] = avg_score + return best_state, new_results def _postprocess_best(results): """ diff --git a/mlxtend/feature_selection/tests/test_generic_selector.py b/mlxtend/feature_selection/tests/test_generic_selector.py index 46d18d0be..868fc2c2f 100644 --- a/mlxtend/feature_selection/tests/test_generic_selector.py +++ b/mlxtend/feature_selection/tests/test_generic_selector.py @@ -5,7 +5,7 @@ import numpy as np from sklearn.linear_model import LinearRegression from mlxtend.feature_selection.generic_selector import FeatureSelector -from mlxtend.feature_selection.strategy import exhaustive, step +from mlxtend.feature_selection.strategy import exhaustive, Stepwise have_pandas = True @@ -90,10 +90,11 @@ def test_step_categorical(): Y = np.random.standard_normal(n) categorical_features = [True] + [False]*9 - strategy = step(X, - max_features=4, - fixed_features=[2,3], - categorical_features=categorical_features) + strategy = Stepwise.first_peak(X, + max_features=4, + fixed_features=[2,3], + initial_features=[2,3], + categorical_features=categorical_features) step_selector = FeatureSelector(LinearRegression(), strategy) @@ -112,10 +113,11 @@ def AIC(estimator, X, Y): Y = np.random.standard_normal(n) categorical_features = [True] + [False]*9 - strategy = step(X, - max_features=4, - fixed_features=[2,3], - categorical_features=categorical_features) + strategy = Stepwise.first_peak(X, + max_features=4, + fixed_features=[2,3], + initial_features=[2,3], + categorical_features=categorical_features) step_selector = FeatureSelector(LinearRegression(), strategy, @@ -144,11 +146,12 @@ def test_step_bigger(): categorical_features = [True] + [False]*(p-1) for direction in ['forward', 'backward', 'both']: - strategy = step(X, - direction=direction, - max_features=p, - fixed_features=[2,3], - categorical_features=categorical_features) + strategy = Stepwise.first_peak(X, + direction=direction, + max_features=p, + fixed_features=[2,3], + initial_features=[2,3], + categorical_features=categorical_features) step_selector = FeatureSelector(LinearRegression(), strategy) @@ -166,10 +169,11 @@ def test_pandas1(): for direction in ['forward', 'backward', 'both']: - strategy = step(D, - direction=direction, - max_features=p, - fixed_features=['A','C']) + strategy = Stepwise.first_peak(D, + direction=direction, + max_features=p, + fixed_features=['A','C'], + initial_features=['A','C']) step_selector = FeatureSelector(LinearRegression(), strategy, @@ -220,11 +224,11 @@ def test_boston_forward(): X = D.values Y = Boston['medv'] - strategy = step(X, - max_features=X.shape[1], - min_features=0, - direction='forward', - parsimonious=False) + strategy = Stepwise.first_peak(X, + max_features=X.shape[1], + min_features=0, + direction='forward', + parsimonious=False) step_selector = FeatureSelector(LinearRegression(), strategy, @@ -273,11 +277,11 @@ def test_boston_both(): X = D.values Y = Boston['medv'] - strategy = step(X, - max_features=X.shape[1], - min_features=0, - direction='both', - parsimonious=False) + strategy = Stepwise.first_peak(X, + max_features=X.shape[1], + min_features=0, + direction='both', + parsimonious=False) step_selector = FeatureSelector(LinearRegression(), strategy, @@ -326,10 +330,11 @@ def test_boston_back(): X = D.values Y = Boston['medv'] - strategy = step(X, - max_features=X.shape[1], - direction='backward', - parsimonious=False) + strategy = Stepwise.first_peak(X, + max_features=X.shape[1], + direction='backward', + initial_features=list(range(X.shape[1])), + parsimonious=False) step_selector = FeatureSelector(LinearRegression(), strategy, @@ -345,3 +350,68 @@ def test_boston_back(): assert(sorted(selected_vars) == sorted(selected_R)) assert(np.fabs(neg_AIC(selected_model, Xsel, Y) + 3023.726) < 0.01) +def test_boston_forward_3step(): + """Ran the following R cell + ```{R} + library(MASS) + data(Boston) + M=step(glm(medv ~ 1, data=Boston), list(upper=glm(medv ~ ., data=Boston)), direction='forward', trace=FALSE, steps=3) + print(AIC(M)) + names(coef(M)[2:4]) + ``` + + Output: + + [1] 3116.097 + [1] "lstat" "rm" "ptratio" + + """ + + try: + import statsmodels.api as sm + except ImportError as e: + warnings.warn('import of statsmodels failed') + return + + selected_R = ["lstat", "rm", "ptratio"] + + Boston = sm.datasets.get_rdataset('Boston', package='MASS').data + D = Boston.drop('medv', axis=1) + X = D.values + Y = Boston['medv'] + + strategy = Stepwise.first_peak(X, + max_features=3, + min_features=3, + initial_features=[], + direction='forward', + parsimonious=False) + + step_selector = FeatureSelector(LinearRegression(), + strategy, + scoring=neg_AIC, + cv=None) + step_selector.fit(X, Y) + selected_vars = [D.columns[j] for j in step_selector.selected_state_] + + strategy2 = Stepwise.fixed_size(X, + 3, + max_features=X.shape[1], + min_features=0, + initial_features=[], + direction='forward') + step_selector2 = FeatureSelector(LinearRegression(), + strategy2, + scoring=neg_AIC, + cv=None) + step_selector2.fit(X, Y) + selected_vars2 = [D.columns[j] for j in step_selector2.selected_state_] + print(selected_vars, selected_vars2) + + Xsel = X[:,list(step_selector.selected_state_)] + selected_model = LinearRegression().fit(Xsel, Y) + + assert(sorted(selected_vars) == sorted(selected_R)) + assert(sorted(selected_vars2) == sorted(selected_R)) + assert(np.fabs(neg_AIC(selected_model, Xsel, Y) + 3116.097) < 0.01) + From 9a4907ee5279bc6f2d4ad9bc2d83bc9cbe57cca8 Mon Sep 17 00:00:00 2001 From: rasbt Date: Mon, 29 Nov 2021 12:24:25 -0600 Subject: [PATCH 14/14] fix ci --- .appveyor.yml | 34 - .github/workflows/python-package-conda.yml | 38 + .travis.yml | 51 - README.md | 4 +- ci/.travis_install.sh | 70 -- ci/.travis_test.sh | 47 - docs/sources/CHANGELOG.md | 41 +- .../evaluate/bootstrap_point632_score.ipynb | 74 +- .../SequentialFeatureSelector.ipynb | 4 +- .../SequentialFeatureSelector_44_1.png | Bin 14180 -> 14015 bytes .../SequentialFeatureSelector_47_0.png | Bin 17244 -> 17089 bytes .../SequentialFeatureSelector_81_1.png | Bin 14185 -> 14318 bytes .../sources/user_guide/plotting/heatmap.ipynb | 35 +- .../StackingRegressor_11_1.png | Bin 11841 -> 11686 bytes .../StackingRegressor_17_1.png | Bin 11961 -> 11745 bytes environment.yml | 14 + mlxtend/__init__.py | 4 +- mlxtend/classifier/ensemble_vote.py | 8 +- mlxtend/evaluate/bootstrap_point632.py | 31 +- .../evaluate/tests/test_bootstrap_point632.py | 12 +- mlxtend/externals/name_estimators.py | 3 +- mlxtend/externals/six.py | 868 ------------------ .../tests/test_exhaustive_feature_selector.py | 18 +- .../tests/test_sequential_feature_selector.py | 8 +- .../frequent_patterns/association_rules.py | 3 + .../tests/test_association_rules.py | 7 + mlxtend/plotting/heatmap.py | 3 +- mlxtend/utils/base_compostion.py | 3 +- setup.cfg | 3 + 29 files changed, 232 insertions(+), 1151 deletions(-) delete mode 100644 .appveyor.yml create mode 100644 .github/workflows/python-package-conda.yml delete mode 100644 .travis.yml delete mode 100755 ci/.travis_install.sh delete mode 100755 ci/.travis_test.sh create mode 100644 environment.yml delete mode 100644 mlxtend/externals/six.py diff --git a/.appveyor.yml b/.appveyor.yml deleted file mode 100644 index 8bed055ea..000000000 --- a/.appveyor.yml +++ /dev/null @@ -1,34 +0,0 @@ -build: false - -environment: - matrix: - - PYTHON_VERSION: 3.8 - MINICONDA: C:/Miniconda37-x64 -init: - - ECHO %PYTHON_VERSION% %MINICONDA% - - ECHO conda --version - -install: - - set PATH=%MINICONDA%;%MINICONDA%\\Scripts;%PATH% - - conda config --set always_yes yes --set changeps1 no - - conda update -q conda - - conda info -a - - conda create -q -n test-environment python=%PYTHON_VERSION% numpy scipy scikit-learn pandas joblib pytest - - activate test-environment - - conda install -c conda-forge dlib - - conda install imageio - - conda install scikit-image - -test_script: - - set PYTHONPATH=%PYTHONPATH%;%CD% - - pytest -sv --ignore=mlxtend/plotting - -notifications: - - # Email - - provider: Email - to: - - mail@sebastianraschka.com - subject: 'Build {{status}}' - message: "{{message}}, {{commitId}}, ..." - on_build_status_changed: true \ No newline at end of file diff --git a/.github/workflows/python-package-conda.yml b/.github/workflows/python-package-conda.yml new file mode 100644 index 000000000..85ff51008 --- /dev/null +++ b/.github/workflows/python-package-conda.yml @@ -0,0 +1,38 @@ +name: Python Package using Conda + +on: [push] + +jobs: + build-linux: + runs-on: ubuntu-latest + strategy: + max-parallel: 5 + + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.8 + uses: actions/setup-python@v2 + with: + python-version: 3.8 + - name: Add conda to system path + run: | + # $CONDA is an environment variable pointing to the root of the miniconda directory + echo $CONDA/bin >> $GITHUB_PATH + - name: Install dependencies + run: | + conda env update --file environment.yml --name base + - name: Lint with flake8 + run: | + conda install flake8 + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + - name: Test with pytest + run: | + conda install numpy scipy scikit-learn pandas tensorflow joblib pytest + conda install imageio scikit-image + conda install -c conda-forge dlib + pip install markdown + pip install -e . + pytest -sv diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index febe8208b..000000000 --- a/.travis.yml +++ /dev/null @@ -1,51 +0,0 @@ -language: generic - -cache: - apt: true - directories: - - $HOME/.cache/pip - - $HOME/.ccache - -dist: trusty - -env: - global: - # Directory where tests are run from - - TEST_DIR=/tmp/sklearn - - OMP_NUM_THREADS=4 - - OPENBLAS_NUM_THREADS=4 - -matrix: - include: - - os: linux - sudo: required - python: 3.8 - env: LATEST="false" IMAGE="false" COVERAGE="false" NUMPY_VERSION="1.18.5" SCIPY_VERSION="1.5.0" SKLEARN_VERSION="0.23.1" JOBLIB_VERSION=0.15.1 PANDAS_VERSION="1.0.5" IMAGEIO_VERSION="2.8.0" SKIMAGE_VERSION="0.17.2" DLIB_VERSION="19.20.0" MINICONDA_PYTHON_VERSION=3.7 - - os: linux - python: 3.8 - env: LATEST="true" IMAGE="false" COVERAGE="true" NOTEBOOKS="false" MINICONDA_PYTHON_VERSION=3.7 - - os: linux - sudo: required - python: 3.8 - env: LATEST="true" IMAGE="false" COVERAGE="false" NOTEBOOKS="false" MINICONDA_PYTHON_VERSION=3.7 - - -before_install: - #- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; fi - -install: - #- if [[ "$TRAVIS_OS_NAME" != "osx" ]]; then sudo apt-get update; fi - - source ci/.travis_install.sh - -script: - - bash ci/.travis_test.sh - -after_success: - - if [[ "$COVERAGE" == "true" ]]; then coveralls || echo "failed"; fi - -notifications: - email: - recipients: - - mail@sebastianraschka.com - on_success: always - on_failure: always diff --git a/README.md b/README.md index a5377a048..8bade55c1 100644 --- a/README.md +++ b/README.md @@ -143,6 +143,4 @@ according to the terms and conditions of the Creative Commons Attribution 4.0 In ## Contact -I received a lot of feedback and questions about mlxtend recently, and I thought that it would be worthwhile to set up a public communication channel. Before you write an email with a question about mlxtend, please consider posting it here since it can also be useful to others! Please join the [Google Groups Mailing List](https://groups.google.com/forum/#!forum/mlxtend)! - -If Google Groups is not for you, please feel free to write me an [email](mailto:mail@sebastianraschka.com) or consider filing an issue on [GitHub's issue tracker](https://github.com/rasbt/mlxtend/issues) for new feature requests or bug reports. In addition, I setup a [Gitter channel](https://gitter.im/rasbt/mlxtend?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) for live discussions. +The best way to ask questions is via the [GitHub Discussions channel](https://github.com/rasbt/mlxtend/discussions). In case you encounter usage bugs, please don't hesitate to use the [GitHub's issue tracker](https://github.com/rasbt/mlxtend/issues) directly. diff --git a/ci/.travis_install.sh b/ci/.travis_install.sh deleted file mode 100755 index 0dab677ba..000000000 --- a/ci/.travis_install.sh +++ /dev/null @@ -1,70 +0,0 @@ -#!/usr/bin/env bash - -set -e - -if [[ "$TRAVIS_OS_NAME" != "osx" ]]; then - if [ "${TRAVIS_PYTHON_VERSION}" == "2.7" ]; then - - wget https://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh -O miniconda.sh - else - wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh - fi -else - if [ "${TRAVIS_PYTHON_VERSION}" == "2.7" ]; then - - wget https://repo.continuum.io/miniconda/Miniconda2-latest-MacOSX-x86_64.sh -O miniconda.sh - else - wget https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh - fi -fi - - -bash miniconda.sh -b -p "$HOME/miniconda" -export PATH="$HOME/miniconda/bin:$PATH" -hash -r -conda config --set always_yes yes --set changeps1 no -conda update -q conda -conda update -q pip -conda info -a - -conda create -q -n test-environment python="$MINICONDA_PYTHON_VERSION" -source activate test-environment - -if [ "${LATEST}" = "true" ]; then - conda install numpy scipy pandas scikit-learn joblib -else - conda install numpy="$NUMPY_VERSION" scipy="$SCIPY_VERSION" pandas="$PANDAS_VERSION" joblib="$JOBLIB_VERSION" - # temporary fix because 0.22 cannot be installed from the main conda branch - conda install scikit-learn="$SKLEARN_VERSION" -c conda-forge -fi - - -conda install matplotlib -conda install jupyter -conda install pytest - - -if [ "${IMAGE}" = "true" ]; then - - if [ "${LATEST}" = "true" ]; then - pip install dlib - pip install imageio - pip install scikit-image - else - pip install dlib=="$DLIB_VERSION" - pip install imageio=="$IMAGEIO_VERSION" - pip install scikit-image=="$SKIMAGE_VERSION" - fi -fi - -if [ "${COVERAGE}" = "true" ]; then - conda install pytest-cov - conda install coveralls -fi - -python --version -python -c "import pandas; print('pandas %s' % pandas.__version__)" -python -c "import numpy; print('numpy %s' % numpy.__version__)" -python -c "import scipy; print('scipy %s' % scipy.__version__)" -python -c "import sklearn; print('sklearn %s' % sklearn.__version__)" -python -c "import mlxtend; print('mlxtend %s' % mlxtend.__version__)" diff --git a/ci/.travis_test.sh b/ci/.travis_test.sh deleted file mode 100755 index 5e852746b..000000000 --- a/ci/.travis_test.sh +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/env bash - -set -e - -python --version -python -c "import pandas; print('pandas %s' % pandas.__version__)" -python -c "import numpy; print('numpy %s' % numpy.__version__)" -python -c "import scipy; print('scipy %s' % scipy.__version__)" -python -c "import sklearn; print('sklearn %s' % sklearn.__version__)" -python -c "import mlxtend; print('mlxtend %s' % mlxtend.__version__)" - -if [[ "$TRAVIS_OS_NAME" != "osx" ]]; then - - - if [[ "$COVERAGE" == "true" ]]; then - - if [[ "$IMAGE" == "true" ]]; then - PYTHONPATH='.' pytest -sv --cov=mlxtend - else - PYTHONPATH='.' pytest -sv --cov=mlxtend --ignore=mlxtend/image - fi - - else - if [[ "$IMAGE" == "true" ]]; then - PYTHONPATH='.' pytest -sv - else - PYTHONPATH='.' pytest -sv --ignore=mlxtend/image - fi - fi - -else - PYTHONPATH='.' pytest -sv --ignore=mlxtend/plotting -fi - - -if [[ "$NOTEBOOKS" == "true" ]]; then - cd docs - - if [[ "$IMAGE" == "true" ]]; then - python make_api.py - find sources -name "*.ipynb" -exec jupyter nbconvert --to notebook --execute {} \; - else - python make_api.py --ignore_packages "mlxtend.image" - find sources -name "*.ipynb" -not -path "sources/user_guide/image/*" -exec jupyter nbconvert --to notebook --execute {} \; - - fi -fi \ No newline at end of file diff --git a/docs/sources/CHANGELOG.md b/docs/sources/CHANGELOG.md index d64eeb6f1..d98057baf 100755 --- a/docs/sources/CHANGELOG.md +++ b/docs/sources/CHANGELOG.md @@ -7,11 +7,41 @@ The CHANGELOG for the current development version is available at --- -### Version 0.18.1 (TBD) +### Version 0.20.0 (TBD) ##### Downloads -- - +- [Source code (zip)](https://github.com/rasbt/mlxtend/archive/v0.20.0.zip) + +- [Source code (tar.gz)](https://github.com/rasbt/mlxtend/archive/v0.20.0.tar.gz) + + + +##### New Features + +- + +##### Changes + +- Due to compatibility issues with newer package versions, certain functions from six.py have been removed so that mlxtend may not work anymore with Python 2.7. +- As an internal change to speed up unit testing, unit testing is now faciliated by GitHub workflows, and Travis CI and Appveyor hooks have been removed. +##### Bug Fixes + +- Fix unreadable labels in `heatmap` for certain colormaps. ([#852](https://github.com/rasbt/mlxtend/pull/852)) + + + + + +### Version 0.19.0 (09/02/2021) + +##### Downloads + +- [Source code (zip)](https://github.com/rasbt/mlxtend/archive/v0.19.0.zip) + +- [Source code (tar.gz)](https://github.com/rasbt/mlxtend/archive/v0.19.0.tar.gz) + + ##### New Features @@ -27,11 +57,14 @@ The CHANGELOG for the current development version is available at - Removes deprecated `res` argument from `plot_decision_regions`. ([#803](https://github.com/rasbt/mlxtend/pull/803)) - Adds a `title_fontsize` parameter to `plot_learning_curves` for controlling the title font size; also the plot style is now the matplotlib default. ([#818](https://github.com/rasbt/mlxtend/pull/818)) - Internal change using `'c': 'none'` instead of `'c': ''` in `mlxtend.plotting.plot_decision_regions`'s scatterplot highlights to stay compatible with Matplotlib 3.4 and newer. ([#822](https://github.com/rasbt/mlxtend/pull/822)) -- Adds a `fontcolor_threshold` parameter to the `mlxtend.plotting.plot_confusion_matrix` function as an additional option for determining the font color cut-off manually. ([#825](https://github.com/rasbt/mlxtend/pull/825)) +- Adds a `fontcolor_threshold` parameter to the `mlxtend.plotting.plot_confusion_matrix` function as an additional option for determining the font color cut-off manually. ([#827](https://github.com/rasbt/mlxtend/pull/827)) +- The `frequent_patterns.association_rules` now raises a `ValueError` if an empty frequent itemset DataFrame is passed. ([#843](https://github.com/rasbt/mlxtend/pull/843)) +- The .632 and .632+ bootstrap method implemented in the `mlxtend.evaluate.bootstrap_point632_score` function now use the whole training set for the resubstitution weighting term instead of the internal training set that is a new bootstrap sample in each round. ([#844](https://github.com/rasbt/mlxtend/pull/844)) ##### Bug Fixes -- - +- Fixes a typo in the SequentialFeatureSelector documentation ([#835](https://github.com/rasbt/mlxtend/issues/835) via [João Pedro Zanlorensi Cardoso](https://github.com/joaozanlorensi)) + ### Version 0.18.0 (11/25/2020) diff --git a/docs/sources/user_guide/evaluate/bootstrap_point632_score.ipynb b/docs/sources/user_guide/evaluate/bootstrap_point632_score.ipynb index 1fc6016ce..e21417d1a 100644 --- a/docs/sources/user_guide/evaluate/bootstrap_point632_score.ipynb +++ b/docs/sources/user_guide/evaluate/bootstrap_point632_score.ipynb @@ -54,16 +54,16 @@ "\n", "Now, to address the bias that is due to this the sampling with replacement, Bradley Efron proposed the *.632 Estimate* that we mentioned earlier, which is computed via the following equation:\n", "\n", - "$$\\text{ACC}_{boot} = \\frac{1}{b} \\sum_{i=1}^b \\big(0.632 \\cdot \\text{ACC}_{h, i} + 0.368 \\cdot \\text{ACC}_{r, i}\\big), $$\n", + "$$\\text{ACC}_{boot} = \\frac{1}{b} \\sum_{i=1}^b \\big(0.632 \\cdot \\text{ACC}_{h, i} + 0.368 \\cdot \\text{ACC}_{train}\\big), $$\n", "\n", - "where $\\text{ACC}_{r, i}$ is the resubstitution accuracy, and $\\text{ACC}_{h, i}$ is the accuracy on the out-of-bag sample.\n", + "where $\\text{ACC}_{train}$ is the accuracy computed on the whole training set, and $\\text{ACC}_{h, i}$ is the accuracy on the out-of-bag sample.\n", "\n", "### .632+ Bootstrap\n", "\n", "Now, while the *.632 Boostrap* attempts to address the pessimistic bias of the estimate, an optimistic bias may occur with models that tend to overfit so that Bradley Efron and Robert Tibshirani proposed the *The .632+ Bootstrap Method* (Efron and Tibshirani, 1997). Instead of using a fixed \"weight\" $\\omega = 0.632$ in\n", "\n", "$$\n", - "ACC_{\\text{boot}} = \\frac{1}{b} \\sum_{i=1}^b \\big(\\omega \\cdot \\text{ACC}_{h, i} + (1-\\omega) \\cdot \\text{ACC}_{r, i} \\big), $$\n", + "ACC_{\\text{boot}} = \\frac{1}{b} \\sum_{i=1}^b \\big(\\omega \\cdot \\text{ACC}_{h, i} + (1-\\omega) \\cdot \\text{ACC}_{train} \\big), $$\n", "\n", "we compute the weight $\\gamma$ as\n", "\n", @@ -71,9 +71,9 @@ "\n", "where *R* is the *relative overfitting rate*\n", "\n", - "$$R = \\frac{(-1) \\times (\\text{ACC}_{h, i} - \\text{ACC}_{r, i})}{\\gamma - (1 -\\text{ACC}_{h, i})}.$$\n", + "$$R = \\frac{(-1) \\times (\\text{ACC}_{h, i} - \\text{ACC}_{train})}{\\gamma - (1 -\\text{ACC}_{h, i})}.$$\n", "\n", - "(Since we are plugging $\\omega$ into the equation for computing $$ACC_{boot}$$ that we defined above, $$\\text{ACC}_{h, i}$$ and $\\text{ACC}_{r, i}$ still refer to the resubstitution and out-of-bag accuracy estimates in the *i*th bootstrap round, respectively.)\n", + "(Since we are plugging $\\omega$ into the equation for computing $$ACC_{boot}$$ that we defined above, $$\\text{ACC}_{h, i}$$ and $\\text{ACC}_{train}$ still refer to the out-of-bag accuracy in the *i*th bootstrap round and the whole training set accuracy, respectively.)\n", "\n", "Further, we need to determine the *no-information rate* $\\gamma$ in order to compute *R*. For instance, we can compute $\\gamma$ by fitting a model to a dataset that contains all possible combinations between samples $x_{i'}$ and target class labels $y_{i}$ — we pretend that the observations and class labels are independent:\n", "\n", @@ -121,8 +121,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 94.36%\n", - "95% Confidence interval: [88.46, 98.31]\n" + "Accuracy: 94.45%\n", + "95% Confidence interval: [87.71, 100.00]\n" ] } ], @@ -135,7 +135,7 @@ "iris = datasets.load_iris()\n", "X = iris.data\n", "y = iris.target\n", - "tree = DecisionTreeClassifier(random_state=0)\n", + "tree = DecisionTreeClassifier(random_state=123)\n", "\n", "# Model accuracy\n", "scores = bootstrap_point632_score(tree, X, y, method='oob')\n", @@ -165,8 +165,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 96.57%\n", - "95% Confidence interval: [92.37, 98.95]\n" + "Accuracy: 96.42%\n", + "95% Confidence interval: [92.41, 100.00]\n" ] } ], @@ -179,7 +179,7 @@ "iris = datasets.load_iris()\n", "X = iris.data\n", "y = iris.target\n", - "tree = DecisionTreeClassifier(random_state=0)\n", + "tree = DecisionTreeClassifier(random_state=123)\n", "\n", "# Model accuracy\n", "scores = bootstrap_point632_score(tree, X, y)\n", @@ -209,8 +209,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 96.28%\n", - "95% Confidence interval: [92.10, 98.90]\n" + "Accuracy: 96.29%\n", + "95% Confidence interval: [91.86, 98.92]\n" ] } ], @@ -223,7 +223,7 @@ "iris = datasets.load_iris()\n", "X = iris.data\n", "y = iris.target\n", - "tree = DecisionTreeClassifier(random_state=0)\n", + "tree = DecisionTreeClassifier(random_state=123)\n", "\n", "# Model accuracy\n", "scores = bootstrap_point632_score(tree, X, y, method='.632+')\n", @@ -255,21 +255,21 @@ "text": [ "## bootstrap_point632_score\n", "\n", - "*bootstrap_point632_score(estimator, X, y, n_splits=200, method='.632', scoring_func=None, random_seed=None, clone_estimator=True)*\n", + "*bootstrap_point632_score(estimator, X, y, n_splits=200, method='.632', scoring_func=None, predict_proba=False, random_seed=None, clone_estimator=True)*\n", "\n", "Implementation of the .632 [1] and .632+ [2] bootstrap\n", - "for supervised learning\n", + " for supervised learning\n", "\n", - "References:\n", + " References:\n", "\n", - "- [1] Efron, Bradley. 1983. “Estimating the Error Rate\n", - "of a Prediction Rule: Improvement on Cross-Validation.”\n", - "Journal of the American Statistical Association\n", - "78 (382): 316. doi:10.2307/2288636.\n", - "- [2] Efron, Bradley, and Robert Tibshirani. 1997.\n", - "“Improvements on Cross-Validation: The .632+ Bootstrap Method.”\n", - "Journal of the American Statistical Association\n", - "92 (438): 548. doi:10.2307/2965703.\n", + " - [1] Efron, Bradley. 1983. \"Estimating the Error Rate\n", + " of a Prediction Rule: Improvement on Cross-Validation.\"\n", + " Journal of the American Statistical Association\n", + " 78 (382): 316. doi:10.2307/2288636.\n", + " - [2] Efron, Bradley, and Robert Tibshirani. 1997.\n", + " \"Improvements on Cross-Validation: The .632+ Bootstrap Method.\"\n", + " Journal of the American Statistical Association\n", + " 92 (438): 548. doi:10.2307/2965703.\n", "\n", "**Parameters**\n", "\n", @@ -316,6 +316,19 @@ " if the estimator is a regressor.\n", "\n", "\n", + "- `predict_proba` : bool\n", + "\n", + " Whether to use the `predict_proba` function for the\n", + " `estimator` argument. This is to be used in conjunction\n", + " with `scoring_func` which takes in probability values\n", + " instead of actual predictions.\n", + " For example, if the scoring_func is\n", + " :meth:`sklearn.metrics.roc_auc_score`, then use\n", + " `predict_proba=True`.\n", + " Note that this requires `estimator` to have\n", + " `predict_proba` method implemented.\n", + "\n", + "\n", "- `random_seed` : int (default=None)\n", "\n", " If int, random_seed is the seed used by\n", @@ -336,7 +349,7 @@ "\n", "**Examples**\n", "\n", - "\n", + "```\n", " >>> from sklearn import datasets, linear_model\n", " >>> from mlxtend.evaluate import bootstrap_point632_score\n", " >>> iris = datasets.load_iris()\n", @@ -352,8 +365,9 @@ " >>> print('95%% Confidence interval: [%.2f, %.2f]' % (lower, upper))\n", " 95% Confidence interval: [0.90, 0.98]\n", "\n", - "For more usage examples, please see\n", - "[http://rasbt.github.io/mlxtend/user_guide/evaluate/bootstrap_point632_score/](http://rasbt.github.io/mlxtend/user_guide/evaluate/bootstrap_point632_score/)\n", + " For more usage examples, please see\n", + " http://rasbt.github.io/mlxtend/user_guide/evaluate/bootstrap_point632_score/\n", + "```\n", "\n", "\n" ] @@ -369,7 +383,7 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -383,7 +397,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.9.6" }, "toc": { "nav_menu": {}, diff --git a/docs/sources/user_guide/feature_selection/SequentialFeatureSelector.ipynb b/docs/sources/user_guide/feature_selection/SequentialFeatureSelector.ipynb index d029054cb..c8f9c8449 100644 --- a/docs/sources/user_guide/feature_selection/SequentialFeatureSelector.ipynb +++ b/docs/sources/user_guide/feature_selection/SequentialFeatureSelector.ipynb @@ -199,7 +199,7 @@ "*Go to Step 2* \n", "\n", "- In this step, we remove a feature, $x^-$ from our feature subset $X_k$.\n", - "- $x^-$ is the feature that maximizes our criterion function upon re,oval, that is, the feature that is associated with the best classifier performance if it is removed from $X_k$.\n", + "- $x^-$ is the feature that maximizes our criterion function upon removal, that is, the feature that is associated with the best classifier performance if it is removed from $X_k$.\n", "\n", "\n", "**Step 2 (Conditional Inclusion):** \n", @@ -2641,4 +2641,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/docs/sources/user_guide/feature_selection/SequentialFeatureSelector_files/SequentialFeatureSelector_44_1.png b/docs/sources/user_guide/feature_selection/SequentialFeatureSelector_files/SequentialFeatureSelector_44_1.png index 20505414275d4006ed9c9a2f239eb9c27c634bb9..85a62c918304ba16815c913d7b776d0a616bdb4b 100644 GIT binary patch literal 14015 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 literal 14180 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 diff --git a/docs/sources/user_guide/feature_selection/SequentialFeatureSelector_files/SequentialFeatureSelector_47_0.png b/docs/sources/user_guide/feature_selection/SequentialFeatureSelector_files/SequentialFeatureSelector_47_0.png index 6a666cd1b8c6dd3908eda349786f524812c860eb..2cb35f0802d922ba75913b85c89acf63a5e4d4ed 100644 GIT binary patch literal 17089 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 literal 14185 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 diff --git a/docs/sources/user_guide/plotting/heatmap.ipynb b/docs/sources/user_guide/plotting/heatmap.ipynb index f3a09c14d..71577e0fc 100644 --- a/docs/sources/user_guide/plotting/heatmap.ipynb +++ b/docs/sources/user_guide/plotting/heatmap.ipynb @@ -67,7 +67,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -104,7 +104,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -124,7 +124,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Example 2 -- Covariance matrix as heatmap" + "## Example 2 -- Correlation matrix as heatmap" ] }, { @@ -305,7 +305,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -317,10 +317,16 @@ } ], "source": [ + "from matplotlib import cm\n", + "\n", "cols = ['LSTAT', 'INDUS', 'NOX', 'RM', 'MEDV']\n", "\n", - "cm = np.corrcoef(df[cols].values.T)\n", - "hm = heatmap(cm, column_names=cols, row_names=cols)\n", + "corrmat = np.corrcoef(df[cols].values.T)\n", + "fix, ax = heatmap(corrmat, column_names=cols, row_names=cols, cmap=cm.PiYG)\n", + "\n", + "# set colorbar cutoff at -1, 1\n", + "for im in ax.get_images():\n", + " im.set_clim(-1, 1)\n", "\n", "plt.show()" ] @@ -343,7 +349,7 @@ "text": [ "## heatmap\n", "\n", - "*heatmap(matrix, hide_spines=False, hide_ticks=False, figsize=None, cmap=None, colorbar=True, row_names=None, column_names=None, column_name_rotation=45, cell_fmt='.2f', cell_font_size=None)*\n", + "*heatmap(matrix, hide_spines=False, hide_ticks=False, figsize=None, cmap=None, colorbar=True, row_names=None, column_names=None, column_name_rotation=45, cell_values=True, cell_fmt='.2f', cell_font_size=None)*\n", "\n", "Plot a heatmap via matplotlib.\n", "\n", @@ -394,14 +400,19 @@ " Number of degrees for rotating column x-tick labels.\n", "\n", "\n", + "- `cell_values` : bool (default: True)\n", + "\n", + " Plots cell values if True.\n", + "\n", + "\n", "- `cell_fmt` : string (default: '.2f')\n", "\n", - " Format specification for cell values.\n", + " Format specification for cell values (if `cell_values=True`)\n", "\n", "\n", "- `cell_font_size` : int (default: None)\n", "\n", - " Font size for cell values\n", + " Font size for cell values (if `cell_values=True`)\n", "\n", "**Returns**\n", "\n", @@ -412,7 +423,7 @@ "**Examples**\n", "\n", "For usage examples, please see\n", - " [http://rasbt.github.io/mlxtend/user_guide/plotting/heatmap/](http://rasbt.github.io/mlxtend/user_guide/plotting/heatmap/)\n", + " http://rasbt.github.io/mlxtend/user_guide/plotting/heatmap/\n", "\n", "\n" ] @@ -428,7 +439,7 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -442,7 +453,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.9.6" }, "toc": { "nav_menu": {}, diff --git a/docs/sources/user_guide/regressor/StackingRegressor_files/StackingRegressor_11_1.png b/docs/sources/user_guide/regressor/StackingRegressor_files/StackingRegressor_11_1.png index 3a7b0ef8677937fd1f47bd02f7cf7299b9cf6c2f..f212a25d28155f8432e59e982f2161969047f09b 100644 GIT binary patch literal 11686 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 D0!3{b literal 11841 zcmcI~WmJ?=yEZl;Wzm92cXuh>NOuU*9RfqD3<%O9-5>%E4Z{FKBOxi>AzcH~40$%b z@A=;Eob{gX$G6sDEguBtdG@pSzW04!_jO&NuT*4lu}QHpFfefC<)qXxFm6D={|_A7KG+<$oe@5bPa|2g=jpu4oLyM~jcyXR|H z3k-+X?#}j3?)Elj&pa$#-E5p3pK-HsuyL|HvvzlP7Gh`r*9X{~T&>t~9U?93ZZYL&wwYFEhcG~2#_NY>TZbaobh_08iv85Ni>4nO6CP?5 zSlAXg=x@^|RWBA(Dmhb46A`o*xyZkNoj6Bn9F2*|)ryk}5ijm$Ug;5Zo8^}*5p>Hq zo0hfUA&tPKg1({=wj+85CCFZq>%30|{UHB8Tm^NJ?>@G*x9cNsQ$ZPGKYaMGXJq_c zf&!bZlHuXQhkp(adChq(0*k81zM`teJq#T9A5R~3Jbk9<89^YykO-~&w^!W)G9zjz zqr1>k{UXA8<0$l1X4QdR3sw<2ao-g>Z5^+|bhSWR+qgjkp`95NDU9kSmchpj+^qs<6M1 z-Z=L2XE`~!XW(nhwMaYc<44&(b9{V!FwO1lZHO^76;;;wnW~~9x6N63m-ZB{w4INF z0yZNfBjNW>SNlUh#E6IF?xbT?^wnxc05PZ8?Zu9$j<&Yk@e=c{ACgrUFjdvNUni48#mmdP>SAmA-8YC(0`oqH;8KJP^&>i^rta>r%ZsyB zq>7vz=H^&Qhc%Du!I~PAc44BE4%lAIeXbfL9UosjE*ameMt?sc&uyHhe6^fv*JW&s zdY@xD0f9s#q{jnNQU&zha+09iw*ur72~4%ybRW<6`^8nw%ofbY)Cx3}(nThQjj*Vo zUJ|Ztuzwpc|5G6SfBs%i!hgEjg~x6*9Pg>n(%E@);5{sC>}T{&P}xY;lr1uAzG@EX8I_rt>5C}qjHwF? zQ|#++Zf;ge;tERPcT&$)h!fd7Jv}A#5y!&9qH{1wrlq6H9^2e!@pN`>>g!V}L$QT_ zp4)F3x1Dl;&%AP;GB-EBKi&RZlA**18SnO(l#)_aTbt0)(J_7;Zni}9C(3{gN?`hp z8m*Qihki;Nx#y%`OojxpFKUdGr_d%XX}!lFl(DSIjPpTE+-0mvN6SVkt3@} zY~ez4FLYodZ!9eIvYt~(>6ykyX9#<4n`i6{<>C9C9&mOP+sA`w6%-WIX{`HuilRS% zHf!sG667Ws?&`}_*VZnquZQXv-K8LJ_VM=aS|g?UVXkM7nahy|gTbJ+1Ph^H8UD8d z?7sz7-GKF*(}Q(raPVN6xvWa6!0X5vY>-2tdXA)nMF#xfZ>?Zw_x!}@=z{MPu@O9d zs%&UT9upH&s1FA#La6=iKLciKYYXHPVw}5wBS*&3^*J;yiFPT4$3{Y3UHyH((^ORi zn^A41dVw{F9)#1}3P@wsNMwrnaf^bxkWukjpO~+tOTDqGt1H)w^vr;hz?Wh;PzF81 z_1H06xR;mLlE~4YKQCY-`etLcmNw?|=e-}i;~PGBRa1Y< zLJ5ix3lbqCX=`iSw>Uhk$wR8#@L!@&TMsr98X77nyL3klHga-uvLqtrf9~~ulMs#@ z<#DVD)9$51`Yi3t96cUB8Xq6Oi71ovRQ~U&iQ!@wJ9EGqtk)f}67_;T-$dBRhVK}w zH9Cg^wSD6&QZ}T6qdVptdpgPuK3X#zq!1=KIK%jO7figXE}CtR{AJbi_B6Mt%EB%cGKo zpB5Gt%Lh>gu5t^#0gijCx#EH@%eSw-UP*de3auxt6PM$B(MjmYO})>if`8$2;_`&( zyUzE>irD=}D2*cRRk8yQ4-YinA}=w{9lYhoErfEN39lz)i)C^+`=g~eobrtt-O{KN zA_;sr<$v)SGIsRSB0D<-jV-M)4DCA3Vaa7Q)!?z5KNM5xDW)#*J!i=eD2CSoHVkw@_R1 zLwPRz7u$_jgWD_KzVs+O9d{i89~6sKNt(q>#-^+B*u+ng0M)C2*17%W0A`*1)I8+9 zrlFzzGNQ$o%`+kr3~5kb60PwdIcZ$@VNJ<#>>u%s%+!B*dlZKz zUz-3|gmm82L%^g`@2*^tJ4ku`lT0DbXIH zxH>vxhFKXI*^#pkBy4Dwy7RNcRRa*TZj6cyHYTKqeFvr7Ap8c}B z`#^W|W#-t}aK~)lY@vg*yYr96TJg(~3rHZpYrILLo2brO2Ys8H2wH&1$#7{QBJ7;- z*r2c0SgUUB)K^E}8~$Uc`4QZ2mLuTvfUpEZ1k{&NYy6z;PTISk`0d2LNoqUF+o!qr zWH-jP4ZAChm-phZ3Q10$^?;EznM1s{53#o%A)t9oV$vZ_m{bi^g56xWNvSp7!6#q6 z7CtY8Ajvz@xqSpY_sQL|S2;ckYBK4BTJk0jWUJi&uz6df#?XSqh}u3K40~W5;NwrP zK`C}4DLtvLLGdg^F_ikZ{>=cRv#^w7#}$YX0^6~sMWj^wnXxKFkM~ztSM%)qyCbB( zGWBnH^Q~jO6VvGbgkl!(*d$i#$d;3nH{De;H&Zv2am#fPw3&E6*~FL?v=FEmjdkrIq{!+5sI!`3YZ4s#1b z6dA7DlY-d`IVZf^IvzCJrpv$M3PtKZJHDSuB<71*wH32MeGV!W00XSK5S^#id&gUx z#qVCc->LChH0yJ_j*cUL6xR2{XXAF71zGto*s)9U>WOE)1zHX8SND3mea|~OSSISB zaM{uFqfUJxk*W8guOC4MHl^(nn4oQPod#+zFSetO5SzH(9%*xJ-xp!yo-QVRd&ye1 zdzM4|HY>B?r3o#C15kCCOdM%XfS=f-NmWyi1AD@4{m%B22>b9kIqTL}bV14sai=A^ zNF^$TRA^nCNb#H~vQc!|0~;1uVm1@{*6?h#S$@cM!}Y+of&L=-n7Z1Z0~};NVU(?! zrdv^aYPuWo*`)3za=Ec*jx&Rm9#OiyM5sUP)cmznzVgVy!EMePii(a#+)PtR*l81< zxY+hg-R7`cW#Rkb&}8b%aa9|I#CJk?ry!E+gHkF|auwP3(~D1dxRJd}7alwNZB^_i zzEi6|Qa@20Xfi0*Cvz3F(irdiD7P3hL_+I=EGV1ByP_>j$IwPB;^nE-I*}NrPFAWV zt3JCP-3UnA*%Pd1-1!TJL7gfwbz>`{gj>2z(?xEA&f6HTO`zAI3l?_$@vj1rV;wcKF1f>veM6DDpkdl72= zsQJyr614k%-VfvO+|2}|-Qxo*iSgSlfi1oMHxdcr>8PAuPta>R<<6K%PhX=(yOM-$*^qd~gXhWyO&Pys+|m)?+f%k=exN@bc9#N| zc+Ov>-ek>T@BmjrH`bRPUV2dI-XQen2`awIy!ri|wL$k2yL0pbTs1U>prbl+k!HRq zv(6k6jG*Y7NV3u!x1xf>MpsIP8@)EC5Py=ET0hSyc6RoZdL&7RaAHC3*ChBysqzOX zOgT;NEjP2H=@%)JN3FXMGmXo6#^RhDZ=R`Y`E^ZNOp4IMA4z`r=xlq+7=L8&34!Ea zElxB4>%b0DpOC`FR*)!SBovQ$^ z`nZdQit^DTNu&n~6BpNFAX^%eZi4h+RZii{{UQN>#LB>d(c`1o2J zmwH(n`z8Ft_`x>aQN&aSS zkx}z8bP$_8;Pf2azCI$@Z}ui=0-KwL3pDg<-5E(Eg8%$+mXMIh*C{bBKAc22sY*#f z3y{o*<>lqNZf|fOkUc+PK4i!6g`v6XyWMNW#TM!^e=P=(xV^B1z$iDT{2fKpg;`z*Il=r}?1 z*4hM)6L0FV#9YpIMJ4!X+LkN6sSDo@)Z$YkNRBYS?L z8f*ig$E#SQz0}jwBaV>4qkp;*=4ax}v&?|8-M5Y7AoRu2f5y4eb4hcd;9*hgAc{@7 zaN;QWh*xje<-tcbO0(b1LF9G5(Ik!irrYr~2Y74BjhX(Mj3%`G7uLORv*L;xcB&>F z8H}e`xlRyZ7v0x>-H?@))h;&t2~gq_d)*pxyw0z!^Iq;FvQ^H zvCPam(J+2Qcc8F_#k~eW$2aPvla9F8uTYIDD=WL>Xzto+$3v>FaaA9bstxOPgYohs z0#^0c2XgLZ_@5ROAmN|3ib+tctR_!SKbb59P<1B;RpfB{-8$PFb#wZ?wPp{_L0p~Y z4lQ3jGPHFSpL_9`#9pBGJ!Rx&Q-6p5x3P+Pue^0(0bwC?4&uG(+cF`a&GwFE0s;cq z46B=#yAytPc0OZb`V<`72 z4ABdpha>!-5GKCD^z+N#2C9nW)94BVtVCfZCdvjoRc}bS(3kx?>j!@HRcSMK&xJ|S z2xxnks3G_6-FyE0IkABAv%7)sw`Y)xC{! z+SeIDja5X{RUN_LMMDnO2Er*sC&`iJ)nWW> zT&D>Gg@WaG-zCS{anX6d~LkQKDy@4aSSN&TgL6p6yBYQ|gj5e(pc^>x<_$ z5O79gnCnMof&PxGQ2Pr*(%S-zWA5$!^%Yh0T2xeZhD*jC-ZIH~i|MTQHY@p4a<@^9 zzgS+kOkGXiB4FI4#`VrSe$vL5Av%~E2vv*zHc_Q%k(gd9KJKz*sdN{J4BkVj(CFv@ z=z#UoShWdBjVle2qajA7POPz#z3_ues(xpI_2dUp09}8A!R-3v&urtqmkIcC`lugq zc(m$zWXve%-A^N)^%ZauJN}j${lt=<>MHuju+*#(nk_}u{%+IUPzI!a^}*JDCiC}9 zpK@%q#I4f)(ae{(&J8aTYy9XMFAm8nJo_z=(KAX;!cW2Wp^*bX;)Ej|s&48*8SjTc`Frb^=ALwjbQYs` zE%x@_gbFzWol*Dve^_PXXE3UZcQK``M{$rwobNT7ctt;|Dkt|2<(BmWuZCz#mRfwUHks!x5 zMl7F_89++k&iR7YVh7GS=I_;|AC;@;W*3%+Qlp0^hbqqspVku|J_mDCw&i=>n_@@2 z#E*%xU=>R1o212#35%T!Rc#S}J(cg^RqI`TwdH^F+wD^OopQrguONo-Y)LWY44I{p zm=oF43V@cTnW}g7PON-~4#_rZL=z)ll#Iourn0=!vvDidQB&tpuId-@z3hS-e{~UD9yM<=RM4D-@`_`7U^bbWc7(HGkC* zAJz6D(6D68;JcJ`?EQ9yU{Fw;_8aO9cPwVlkCcxxX8PZa+!BDC(F`G#I^u<#hE3bUK^5K|VSzFGzt#bcObL1UYb?v3B z@M!)uL2onzDG{#StZ{4mZ!#AR`VU7aKFLj$Y4j_yxPFS>U*4`kP` z)B^?&Y;ewOh@Y;!ec@vurrFl`_`%+jR3_)$oG>Z;kZ%U2{F+Q!4YG0g*C_;z{=K+J zeZz_F&RfX!a|(2epI=9;mZZ*a?dFKNsEf#eui|8jeELWpH3f#}OE;L}N}!XMa~zQA zfgJb#FX12Ahx+Ln?Yc4XvFZI?MW}Eksy$XopRRf?iHl!;^jSYHG)gYzs(|_e_7^n? zrv}uqbQs|>M2wm`Fos(8A)qm%C`9EH6u3GZDK}kYqXtDaxG3tCOln(LVBT>X_7JE0 z6+S)f1I;ld9{$q54xU9CikP7Wp-+;?_dw<^(8w!)^YdYLcJ_F+3$;~W>Q8vzcP&`H zX2C;)D*G&xM*p64(W&7X!ta?mU4Xz*T>J72kc7UzzF(Pp6aWWwjbHC|JpF-4W)H}{ zlpfMkMlVIFa=alaG)gbM87nC!CYG)bw*|Qwm;C8dto!%Pr>Y!kMkgBlgaHkEClg$@ z<{BG+$lmBw%PqBtu;ZiiFk@-e$CY&Y#ckP3JlW&Wx}1_w1eSp#R?-+Yvhe$N%)V~U zz!C{p-iU31b`dEC9v+@%p>9m$)#cQ%5s^Y9QxGfjj&3@nq<``FL1RwA*Vk4HD(Pu^ zEaH@x6O*}E_nF@6)X~vAzRHfQtmKKUVu#toXP!B*D@@r54_h8?!a_qLO*?9yUIXzA zkEsD1qJ-{2~3`8dP%*`bDFFMli9UvDIrIC zgj3!sGAouL&TS!VJGDq<_Ckl#j2f$wBEd@#y$?wI%4jVS{f{csLH&GfXV3 zpYXp#_-N5B)BTlR9*0Suet9)2sh{cvnm7)EU#K5N5$JM917>CaIzN_CefY{O?+P!M z0NW3iO-f3N!+HJ%K(hUICH27w1b;@rC8Q5)9N=6agaEpU#i;hn@m#>%QcDm)+Ysot zkD{jf6LmUFe{_PX<7M7PW;kfnRZ(nMWO$U6t11TQ_4)aE!|qwX zGG@R+3kV79sU1gojqGU6o*uC-Xe?q~F{ZjSFRl%iD)#X^)aci2G5c9*K?w+l2J>iL z9=N#Uu66lc_&u+Z;Q$3^S^-I`!^{i?`VC)S??eRePT}j`C~yqLqLDV9AZER8KHQTCxhZP2Yvcd)h68tnkmE9U@A&@o=v#TC`vGXyl!DeL9e)u)P0@RA0Z+fQH01 z9#R9@H9Fo|8>+?!Rk6Ko1uQ%^v(=Wj`8xO#Sf@;#|EbL3hOGN!m>zm(5F7Z`KXzIj1vMKsVmk zvi4WF2xg-)!MW4BO11Bcnaj{M=NgBtrF+%qO?ady2g-sk;!2oQ)u9LUC9JQq(2R#< zwNPKq$L?3UNvo0!(rQ=nfTz4}Gv6#cNQa@xS4%ST+UQw{k(Mm$rw0#<2kX9^;u=Xb z5HDSpNvwm?U0_^)YQBSW_$MNORMW2My~{n~<4FMwvCBpCIGW0`zn)vjik|0q{Md*I}e`6s=FJj zaXlb}3OXSuELbrgamSvbhD23I6_9=}nuaj|9T9D}C*bO`(qSqd zh+1x&qeZ@B`-g}B+1O@DeoQV`q>>^TtWq0pnb)p8TRLpdsKl_w)qcG6JrKf5oqtPccrZd4%%@XlPW+pW3n^-o zzq4sgB$vhoKfq0D^lMNGGrd6($ALJQQC9i;t`1TS4&ZvNm!d&$%Oi}15iHq{u-c3JjaZ>dKAi)#N1@APGA z*~m9Q2R+{jxa!s${VM+mkFrnrPJuQ|I%mKcy=QTHgz7H0=+4)xuuMNRGdC}Il_lXa zdE|IR|oVp8<>R_$McZBj2@Zybqax*a=#&I3}&{U`j^r9B z_1=d{6Ga5sI84?zOM_K;mpZ>vEA4PS1q65ej)_X3JnqTwCVa@s=Lf2NU!y5Syf}Q0 zw{wA@x;2G}0&3zd=dE#0I;BL6rilux_1SviG@-ZIPIC=7q&#vUk&zu#V>N;92(YE^ zPk!!J9@zXmls}{V1l$Opue|`sG01)jKjg4NN6-_M8pos^EP=G6=;-Z@0B!54-uBK; zRAZw!#{2j0&yS{@zHP~1W?@JtVH7sV`c*~E_5rj{e9>*4ttzufwBGSWMZ>G4*GFJH z<*^>0e6iOP30)~QdJK&M&4Yjf@c`wsurU*_v@?=pwDaLdo}>Y(ZB_#ukV`ScyautF zrkQK@7c(g*0JmeSQ`9@qEqe_jDN*Mk!Zw~PYUR(bb303R^`m$78^=r?dE{2^Qv(>j zo=d`Y^j;Njjvv;TRbgJ&2tti%tftho)T9}6zK`_eD|%5@1GA%CYsi<^NODuYrfJXR z`g0aCrbREb4~&~Xy=2bU%ca|u--TZCf59_xe?~>yJh>dFaGmG5fIK>|8DxCUi(k!ss@qBmF3jnY@LAPH$x=-X6K|6^tn zYQ>2`_axaC={m|v`z1t-L*j z=Lxz`*>f7ciGkd1)p;y=%@Xcc^=h2=D*Rn#iK8bK6WFz8e2t6|CEtv5-CFxnQ@uYw z3Do|zmLx-Sk@h1bjyj*a7_WlAf5maqD6FbO{qK#zpf3dKRaCv%kqf;w3bnOz zH`}kpv_F~7fZeuvRrE6EDEHqBz$>8}Y}m094gMFWJt_QAKV#{Msw10CO*e)M0EB!D zG*&M!0V*mgS8gXNsRFfMKlL$ugnfVt^)**V5wx-so;H*Q{f-u^=(HcSZ4VM2cYMW- zwLVbFNo{fhR}mwbKRbW=wg$xUj}NW-+ioTDt|?=qfenJNR>jv>1ig?NqZ21k*ss0~DG z-gngo*%SPs&BHrYB?1oYJWFSXn;nOnWBV+Wg03_Ula-L{v?oC&B~E1speFmFH{=2eU1}2ofye`%i8c3HL)kf|IHtKrH8=ck;CMR_0L14(xBUhn)zQnE zc*R;p7Qs3w?ZaUZ+UMGvH(SD-5MH|BM zPhs4=Nc(I&OGyIrHSV3X!nYnCeS&KGUt)7WBB-<(59Y(2Dg`iSORPR+qztA9Xz-ti z&w3tjNV+3gaum=^w;^{QERjetmuQP zw({k`F^HgrCEfjNUn`JoZPtfA$BVI|>&8~M#E}`4M;A@O)wo}0UKxHxaZ?;(AKioENEd;Jyrs>^?&L5fU4wg zg8gC25uKPAqLNqPArHJvOo{GR`9L4x47l{|OBd}14gH_v<9^Tj=xBn}w6wB{iq_fL zbhzDEa`}`Ys6;=1{uK1o82g8*E%CxQ6g*=TEGLLYtJyjTutL@RdYiy*q5`0h(u7e1 z;9pdlthh-d0M@xiy1m?tO8_j|6$^b*E*TRaaHWEl(h_dQQgWDL02sIkcxArL&F>={ z^!mVxQ}y*1H5#M|7XWrdx@9BDV!#BamBS zjJXZ8wY3|%xw*MBPT*bNLD!yQvzY_jePjQ$aRddQ13dW2Kou`S=GF^<->`6TX~o1E znxc;n5B(O#{tqw%+)spzxyHpVfLm>+^^ET;XO1QvVW{8_Qxs%m2J?Khvqo+^v!dIx z^(p)Nv-Li^z!b452HK6?-QDKdSqh*arC@sjUl=)n-QDr5mDU3v#IMe;1CGPA31hxF zB;jS?-5bt}?YPDP7jK2$Zb*U5i;0K#4G=fqbie{+zoLsMzJ5O*9-e;J2$|M}wy+z( z`f<1M@)X91d;nHo=~MM}>_}ZI34JD#z>IFj&rJdqxP^ubF1JnxEQgq}B968XUi)1` zqS(&i=ea5W`ZFjy9HBBfFLTwG^}neXxE8w;jndK^2NBTy6suv%u~VSG-n5@!O0>g@ zjO)cmz2C>GdmQnSvMQ z{V%nKSj4Lou2>%8ve;hcwyN@7yQm9DOGQSJ(z(DH`THZKD_9{-rYE94M_&O59c6?4 z$j!^!ZzppCI@kMV(`#lZoS3s^(n9YG_z6H+YaY^u%TqhM1anSMNCbq1&8@6H*4K;L zjTN&_2DfvuadQui*S@t|%vDSXUteEu2PR8W)eJEQR5{DSuPn)S0Jq3mTUrW@KDF7v z^%r*+JAid&z-zVd=`|_ku;AC<)x`z2d<={fK|(^(4p@*yK#15Ze`nd8a%$v_B<1ZA z@cLtFmtdw=qz~ts1<@LcVBVkM1;H`=T`LT92=i-ea=N<2;DHq$dV~X@cVW^g2C`6L z%gjs~C{Z`&7ZyGwBqS(Lf0g*_ro(w*X-SuqlmxMSr&$g>NFLkM@?Kuma79M$F5gZ& zxW0&ph${tn^d$NIX}&i; z5rS|pic~~hhowf$!ZcW0& zPENd3(u6EfpIOX0BA;p&sNWG67YDNiXS2{09A%J16Db4EV}MpjWP{|Q+yj#6@bGYI zhklW^qqZqE=zPGlGtE09K}$P2xvXml{Cr-!ZA26GJ_xvCSqNzCO8w3}z@aAQwS9aK zk9_{(cn$#;DmKjy2!P;7d;un_=MFk6lCyJj8Nh;e-R^O5afN*P^qhv~$D~E*LrWgg zB#zfNjg5^DcIM{5AU(Y){55`Od>A%1HlWwRXJ=<;*0CVTk&U7QAqn&|ZqIGQWIl(k zt%-^vqj>3QU_b=++LiM<&mH5s`uea+ha^gg_4)Z1Qc|~X-NWl4(bpPoPk5Un6LB3k z=in8uPxZVuJBSy$9^x81m98QpFOcAN~UkdydQi diff --git a/docs/sources/user_guide/regressor/StackingRegressor_files/StackingRegressor_17_1.png b/docs/sources/user_guide/regressor/StackingRegressor_files/StackingRegressor_17_1.png index 9bc239a23d37f6fe5976aa5fcd7658bb8dd106b4..70e066347960b59384ecbe9ed88695d3d309f537 100644 GIT binary patch literal 11745 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 G-+uwVS$H!5 literal 11961 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 j{~L+*fB4_2+k4h4xSenouRb6%N0Stj6D<=4.0.1 + - numpy>=1.21.4 + - 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 + - pip: + - markdown>=3.3.6 diff --git a/mlxtend/__init__.py b/mlxtend/__init__.py index 241ca97ed..cf93bdcfb 100644 --- a/mlxtend/__init__.py +++ b/mlxtend/__init__.py @@ -1,7 +1,7 @@ -# Sebastian Raschka 2014-2020 +# Sebastian Raschka 2014-2021 # mlxtend Machine Learning Library Extensions # Author: Sebastian Raschka # # License: BSD 3 clause -__version__ = '0.19.0dev' +__version__ = '0.20.0dev' diff --git a/mlxtend/classifier/ensemble_vote.py b/mlxtend/classifier/ensemble_vote.py index c9494842a..2429fb304 100644 --- a/mlxtend/classifier/ensemble_vote.py +++ b/mlxtend/classifier/ensemble_vote.py @@ -15,7 +15,6 @@ from sklearn.exceptions import NotFittedError from sklearn.preprocessing import LabelEncoder -from ..externals import six from ..externals.name_estimators import _name_estimators @@ -283,12 +282,11 @@ def get_params(self, deep=True): return super(EnsembleVoteClassifier, self).get_params(deep=False) else: out = self.named_clfs.copy() - for name, step in six.iteritems(self.named_clfs): - for key, value in six.iteritems(step.get_params(deep=True)): + for name, step in self.named_clfs.items(): + for key, value in step.get_params(deep=True).items(): out['%s__%s' % (name, key)] = value - for key, value in six.iteritems( - super(EnsembleVoteClassifier, self).get_params(deep=False)): + for key, value in super(EnsembleVoteClassifier, self).get_params(deep=False).items(): out['%s' % key] = value return out diff --git a/mlxtend/evaluate/bootstrap_point632.py b/mlxtend/evaluate/bootstrap_point632.py index 83bc854d0..1b54a39dc 100644 --- a/mlxtend/evaluate/bootstrap_point632.py +++ b/mlxtend/evaluate/bootstrap_point632.py @@ -185,13 +185,32 @@ def bootstrap_point632_score(estimator, X, y, n_splits=200, oob = BootstrapOutOfBag(n_splits=n_splits, random_seed=random_seed) scores = np.empty(dtype=np.float, shape=(n_splits,)) cnt = 0 + for train, test in oob.split(X): cloned_est.fit(X[train], y[train]) # get the prediction probability # for binary class uses the last column predicted_test_val = predict_func(X[test]) - predicted_train_val = predict_func(X[train]) + + if method in ('.632', '.632+'): + # predictions on the internal training set: + # predicted_train_val = predict_func(X[train]) + + # compute training error on the whole training set as reported in + # the original .632 boostrap paper + # in Eq (6.12) in + # "Estimating the Error Rate of a Prediction Rule: Improvement + # on Cross-Validation" + # by B. Efron, 1983, https://doi.org/10.2307/2288636 + # Also see the discussion at + # https://github.com/rasbt/mlxtend/discussions/828 + # + # This also applies to the .632+ estimate in the paper + # "Improvements on Cross-Validation: The .632+ Bootstrap Method" + # https://www.tandfonline.com/doi/abs/10.1080/01621459.1997.10474007 + predicted_train_val = predict_func(X) + if predict_proba: len_uniq = np.unique(y) @@ -206,13 +225,19 @@ def bootstrap_point632_score(estimator, X, y, n_splits=200, else: test_err = 1 - test_acc - train_err = 1 - scoring_func(y[train], predicted_train_val) + + # training error on the whole training set as mentioned in the + # previous comment above + train_err = 1 - scoring_func( + y, predicted_train_val) + if method == '.632+': gamma = 1 - (no_information_rate( y, cloned_est.predict(X), scoring_func)) - R = (test_err - train_err) / (gamma - train_err) + R = (test_err - train_err) / ( + gamma - train_err) weight = 0.632 / (1 - 0.368*R) else: diff --git a/mlxtend/evaluate/tests/test_bootstrap_point632.py b/mlxtend/evaluate/tests/test_bootstrap_point632.py index 71945b420..e091f0885 100644 --- a/mlxtend/evaluate/tests/test_bootstrap_point632.py +++ b/mlxtend/evaluate/tests/test_bootstrap_point632.py @@ -40,7 +40,7 @@ def test_defaults(): scores = bootstrap_point632_score(lr, X, y, random_seed=123) acc = np.mean(scores) assert len(scores == 200) - assert np.round(acc, 5) == 0.95306, np.round(acc, 5) + assert np.round(acc, 5) == 0.95117, np.round(acc, 5) def test_oob(): @@ -58,14 +58,14 @@ def test_632(): method='.632') acc = np.mean(scores) assert len(scores == 200) - assert np.round(acc, 5) == 0.96629, np.round(acc, 5) + assert np.round(acc, 5) == 0.95914, np.round(acc, 5) tree2 = DecisionTreeClassifier(random_state=123, max_depth=1) scores = bootstrap_point632_score(tree2, X, y, random_seed=123, method='.632') acc = np.mean(scores) assert len(scores == 200) - assert np.round(acc, 5) == 0.65512, np.round(acc, 5) + assert np.round(acc, 5) == 0.64355, np.round(acc, 5) def test_632plus(): @@ -74,14 +74,14 @@ def test_632plus(): method='.632+') acc = np.mean(scores) assert len(scores == 200) - assert np.round(acc, 5) == 0.9649, np.round(acc, 5) + assert np.round(acc, 5) == 0.95855, np.round(acc, 5) tree2 = DecisionTreeClassifier(random_state=123, max_depth=1) scores = bootstrap_point632_score(tree2, X, y, random_seed=123, method='.632+') acc = np.mean(scores) assert len(scores == 200) - assert np.round(acc, 5) == 0.64831, np.round(acc, 5) + assert np.round(acc, 5) == 0.64078, np.round(acc, 5) def test_custom_accuracy(): @@ -95,7 +95,7 @@ def accuracy2(targets, predictions): scoring_func=accuracy2) acc = np.mean(scores) assert len(scores == 200) - assert np.round(acc, 5) == 0.95306, np.round(acc, 5) + assert np.round(acc, 5) == 0.95117, np.round(acc, 5) def test_invalid_splits(): diff --git a/mlxtend/externals/name_estimators.py b/mlxtend/externals/name_estimators.py index cb9bea93c..fe4b38b51 100644 --- a/mlxtend/externals/name_estimators.py +++ b/mlxtend/externals/name_estimators.py @@ -1,4 +1,3 @@ -from ..externals import six from collections import defaultdict # The :mod:`sklearn.pipeline` module implements utilities to build a composite @@ -19,7 +18,7 @@ def _name_estimators(estimators): for _, name in zip(estimators, names): namecount[name] += 1 - for k, v in list(six.iteritems(namecount)): + for k, v in list(namecount.items()): if v == 1: del namecount[k] diff --git a/mlxtend/externals/six.py b/mlxtend/externals/six.py deleted file mode 100644 index 190c0239c..000000000 --- a/mlxtend/externals/six.py +++ /dev/null @@ -1,868 +0,0 @@ -"""Utilities for writing code that runs on Python 2 and 3""" - -# Copyright (c) 2010-2015 Benjamin Peterson -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -from __future__ import absolute_import - -import functools -import itertools -import operator -import sys -import types - -__author__ = "Benjamin Peterson " -__version__ = "1.10.0" - - -# Useful for very coarse version differentiation. -PY2 = sys.version_info[0] == 2 -PY3 = sys.version_info[0] == 3 -PY34 = sys.version_info[0:2] >= (3, 4) - -if PY3: - string_types = str, - integer_types = int, - class_types = type, - text_type = str - binary_type = bytes - - MAXSIZE = sys.maxsize -else: - string_types = basestring, - integer_types = (int, long) - class_types = (type, types.ClassType) - text_type = unicode - binary_type = str - - if sys.platform.startswith("java"): - # Jython always uses 32 bits. - MAXSIZE = int((1 << 31) - 1) - else: - # It's possible to have sizeof(long) != sizeof(Py_ssize_t). - class X(object): - - def __len__(self): - return 1 << 31 - try: - len(X()) - except OverflowError: - # 32-bit - MAXSIZE = int((1 << 31) - 1) - else: - # 64-bit - MAXSIZE = int((1 << 63) - 1) - del X - - -def _add_doc(func, doc): - """Add documentation to a function.""" - func.__doc__ = doc - - -def _import_module(name): - """Import module, returning the module after the last dot.""" - __import__(name) - return sys.modules[name] - - -class _LazyDescr(object): - - def __init__(self, name): - self.name = name - - def __get__(self, obj, tp): - result = self._resolve() - setattr(obj, self.name, result) # Invokes __set__. - try: - # This is a bit ugly, but it avoids running this again by - # removing this descriptor. - delattr(obj.__class__, self.name) - except AttributeError: - pass - return result - - -class MovedModule(_LazyDescr): - - def __init__(self, name, old, new=None): - super(MovedModule, self).__init__(name) - if PY3: - if new is None: - new = name - self.mod = new - else: - self.mod = old - - def _resolve(self): - return _import_module(self.mod) - - def __getattr__(self, attr): - _module = self._resolve() - value = getattr(_module, attr) - setattr(self, attr, value) - return value - - -class _LazyModule(types.ModuleType): - - def __init__(self, name): - super(_LazyModule, self).__init__(name) - self.__doc__ = self.__class__.__doc__ - - def __dir__(self): - attrs = ["__doc__", "__name__"] - attrs += [attr.name for attr in self._moved_attributes] - return attrs - - # Subclasses should override this - _moved_attributes = [] - - -class MovedAttribute(_LazyDescr): - - def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): - super(MovedAttribute, self).__init__(name) - if PY3: - if new_mod is None: - new_mod = name - self.mod = new_mod - if new_attr is None: - if old_attr is None: - new_attr = name - else: - new_attr = old_attr - self.attr = new_attr - else: - self.mod = old_mod - if old_attr is None: - old_attr = name - self.attr = old_attr - - def _resolve(self): - module = _import_module(self.mod) - return getattr(module, self.attr) - - -class _SixMetaPathImporter(object): - - """ - A meta path importer to import six.moves and its submodules. - - This class implements a PEP302 finder and loader. It should be compatible - with Python 2.5 and all existing versions of Python3 - """ - - def __init__(self, six_module_name): - self.name = six_module_name - self.known_modules = {} - - def _add_module(self, mod, *fullnames): - for fullname in fullnames: - self.known_modules[self.name + "." + fullname] = mod - - def _get_module(self, fullname): - return self.known_modules[self.name + "." + fullname] - - def find_module(self, fullname, path=None): - if fullname in self.known_modules: - return self - return None - - def __get_module(self, fullname): - try: - return self.known_modules[fullname] - except KeyError: - raise ImportError("This loader does not know module " + fullname) - - def load_module(self, fullname): - try: - # in case of a reload - return sys.modules[fullname] - except KeyError: - pass - mod = self.__get_module(fullname) - if isinstance(mod, MovedModule): - mod = mod._resolve() - else: - mod.__loader__ = self - sys.modules[fullname] = mod - return mod - - def is_package(self, fullname): - """ - Return true, if the named module is a package. - - We need this method to get correct spec objects with - Python 3.4 (see PEP451) - """ - return hasattr(self.__get_module(fullname), "__path__") - - def get_code(self, fullname): - """Return None - - Required, if is_package is implemented""" - self.__get_module(fullname) # eventually raises ImportError - return None - get_source = get_code # same as get_code - -_importer = _SixMetaPathImporter(__name__) - - -class _MovedItems(_LazyModule): - - """Lazy loading of moved objects""" - __path__ = [] # mark as package - - -_moved_attributes = [ - MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), - MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), - MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), - MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), - MovedAttribute("intern", "__builtin__", "sys"), - MovedAttribute("map", "itertools", "builtins", "imap", "map"), - MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), - MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), - MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), - MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"), - MovedAttribute("reduce", "__builtin__", "functools"), - MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), - MovedAttribute("StringIO", "StringIO", "io"), - MovedAttribute("UserDict", "UserDict", "collections"), - MovedAttribute("UserList", "UserList", "collections"), - MovedAttribute("UserString", "UserString", "collections"), - MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), - MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), - MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), - MovedModule("builtins", "__builtin__"), - MovedModule("configparser", "ConfigParser"), - MovedModule("copyreg", "copy_reg"), - MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), - MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"), - MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), - MovedModule("http_cookies", "Cookie", "http.cookies"), - MovedModule("html_entities", "htmlentitydefs", "html.entities"), - MovedModule("html_parser", "HTMLParser", "html.parser"), - MovedModule("http_client", "httplib", "http.client"), - MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), - MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), - MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), - MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), - MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), - MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), - MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), - MovedModule("cPickle", "cPickle", "pickle"), - MovedModule("queue", "Queue"), - MovedModule("reprlib", "repr"), - MovedModule("socketserver", "SocketServer"), - MovedModule("_thread", "thread", "_thread"), - MovedModule("tkinter", "Tkinter"), - MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), - MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), - MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), - MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), - MovedModule("tkinter_tix", "Tix", "tkinter.tix"), - MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), - MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), - MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), - MovedModule("tkinter_colorchooser", "tkColorChooser", - "tkinter.colorchooser"), - MovedModule("tkinter_commondialog", "tkCommonDialog", - "tkinter.commondialog"), - MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), - MovedModule("tkinter_font", "tkFont", "tkinter.font"), - MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), - MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", - "tkinter.simpledialog"), - MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), - MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), - MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), - MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), - MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), - MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), -] -# Add windows specific modules. -if sys.platform == "win32": - _moved_attributes += [ - MovedModule("winreg", "_winreg"), - ] - -for attr in _moved_attributes: - setattr(_MovedItems, attr.name, attr) - if isinstance(attr, MovedModule): - _importer._add_module(attr, "moves." + attr.name) -del attr - -_MovedItems._moved_attributes = _moved_attributes - -moves = _MovedItems(__name__ + ".moves") -_importer._add_module(moves, "moves") - - -class Module_six_moves_urllib_parse(_LazyModule): - - """Lazy loading of moved objects in six.moves.urllib_parse""" - - -_urllib_parse_moved_attributes = [ - MovedAttribute("ParseResult", "urlparse", "urllib.parse"), - MovedAttribute("SplitResult", "urlparse", "urllib.parse"), - MovedAttribute("parse_qs", "urlparse", "urllib.parse"), - MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), - MovedAttribute("urldefrag", "urlparse", "urllib.parse"), - MovedAttribute("urljoin", "urlparse", "urllib.parse"), - MovedAttribute("urlparse", "urlparse", "urllib.parse"), - MovedAttribute("urlsplit", "urlparse", "urllib.parse"), - MovedAttribute("urlunparse", "urlparse", "urllib.parse"), - MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), - MovedAttribute("quote", "urllib", "urllib.parse"), - MovedAttribute("quote_plus", "urllib", "urllib.parse"), - MovedAttribute("unquote", "urllib", "urllib.parse"), - MovedAttribute("unquote_plus", "urllib", "urllib.parse"), - MovedAttribute("urlencode", "urllib", "urllib.parse"), - MovedAttribute("splitquery", "urllib", "urllib.parse"), - MovedAttribute("splittag", "urllib", "urllib.parse"), - MovedAttribute("splituser", "urllib", "urllib.parse"), - MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), - MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), - MovedAttribute("uses_params", "urlparse", "urllib.parse"), - MovedAttribute("uses_query", "urlparse", "urllib.parse"), - MovedAttribute("uses_relative", "urlparse", "urllib.parse"), -] -for attr in _urllib_parse_moved_attributes: - setattr(Module_six_moves_urllib_parse, attr.name, attr) -del attr - -Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes - -_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), - "moves.urllib_parse", "moves.urllib.parse") - - -class Module_six_moves_urllib_error(_LazyModule): - - """Lazy loading of moved objects in six.moves.urllib_error""" - - -_urllib_error_moved_attributes = [ - MovedAttribute("URLError", "urllib2", "urllib.error"), - MovedAttribute("HTTPError", "urllib2", "urllib.error"), - MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), -] -for attr in _urllib_error_moved_attributes: - setattr(Module_six_moves_urllib_error, attr.name, attr) -del attr - -Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes - -_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), - "moves.urllib_error", "moves.urllib.error") - - -class Module_six_moves_urllib_request(_LazyModule): - - """Lazy loading of moved objects in six.moves.urllib_request""" - - -_urllib_request_moved_attributes = [ - MovedAttribute("urlopen", "urllib2", "urllib.request"), - MovedAttribute("install_opener", "urllib2", "urllib.request"), - MovedAttribute("build_opener", "urllib2", "urllib.request"), - MovedAttribute("pathname2url", "urllib", "urllib.request"), - MovedAttribute("url2pathname", "urllib", "urllib.request"), - MovedAttribute("getproxies", "urllib", "urllib.request"), - MovedAttribute("Request", "urllib2", "urllib.request"), - MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), - MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), - MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), - MovedAttribute("BaseHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), - MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), - MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), - MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), - MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), - MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), - MovedAttribute("FileHandler", "urllib2", "urllib.request"), - MovedAttribute("FTPHandler", "urllib2", "urllib.request"), - MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), - MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), - MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), - MovedAttribute("urlretrieve", "urllib", "urllib.request"), - MovedAttribute("urlcleanup", "urllib", "urllib.request"), - MovedAttribute("URLopener", "urllib", "urllib.request"), - MovedAttribute("FancyURLopener", "urllib", "urllib.request"), - MovedAttribute("proxy_bypass", "urllib", "urllib.request"), -] -for attr in _urllib_request_moved_attributes: - setattr(Module_six_moves_urllib_request, attr.name, attr) -del attr - -Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes - -_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), - "moves.urllib_request", "moves.urllib.request") - - -class Module_six_moves_urllib_response(_LazyModule): - - """Lazy loading of moved objects in six.moves.urllib_response""" - - -_urllib_response_moved_attributes = [ - MovedAttribute("addbase", "urllib", "urllib.response"), - MovedAttribute("addclosehook", "urllib", "urllib.response"), - MovedAttribute("addinfo", "urllib", "urllib.response"), - MovedAttribute("addinfourl", "urllib", "urllib.response"), -] -for attr in _urllib_response_moved_attributes: - setattr(Module_six_moves_urllib_response, attr.name, attr) -del attr - -Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes - -_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), - "moves.urllib_response", "moves.urllib.response") - - -class Module_six_moves_urllib_robotparser(_LazyModule): - - """Lazy loading of moved objects in six.moves.urllib_robotparser""" - - -_urllib_robotparser_moved_attributes = [ - MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), -] -for attr in _urllib_robotparser_moved_attributes: - setattr(Module_six_moves_urllib_robotparser, attr.name, attr) -del attr - -Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes - -_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), - "moves.urllib_robotparser", "moves.urllib.robotparser") - - -class Module_six_moves_urllib(types.ModuleType): - - """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" - __path__ = [] # mark as package - parse = _importer._get_module("moves.urllib_parse") - error = _importer._get_module("moves.urllib_error") - request = _importer._get_module("moves.urllib_request") - response = _importer._get_module("moves.urllib_response") - robotparser = _importer._get_module("moves.urllib_robotparser") - - def __dir__(self): - return ['parse', 'error', 'request', 'response', 'robotparser'] - -_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), - "moves.urllib") - - -def add_move(move): - """Add an item to six.moves.""" - setattr(_MovedItems, move.name, move) - - -def remove_move(name): - """Remove item from six.moves.""" - try: - delattr(_MovedItems, name) - except AttributeError: - try: - del moves.__dict__[name] - except KeyError: - raise AttributeError("no such move, %r" % (name,)) - - -if PY3: - _meth_func = "__func__" - _meth_self = "__self__" - - _func_closure = "__closure__" - _func_code = "__code__" - _func_defaults = "__defaults__" - _func_globals = "__globals__" -else: - _meth_func = "im_func" - _meth_self = "im_self" - - _func_closure = "func_closure" - _func_code = "func_code" - _func_defaults = "func_defaults" - _func_globals = "func_globals" - - -try: - advance_iterator = next -except NameError: - def advance_iterator(it): - return it.next() -next = advance_iterator - - -try: - callable = callable -except NameError: - def callable(obj): - return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) - - -if PY3: - def get_unbound_function(unbound): - return unbound - - create_bound_method = types.MethodType - - def create_unbound_method(func, cls): - return func - - Iterator = object -else: - def get_unbound_function(unbound): - return unbound.im_func - - def create_bound_method(func, obj): - return types.MethodType(func, obj, obj.__class__) - - def create_unbound_method(func, cls): - return types.MethodType(func, None, cls) - - class Iterator(object): - - def next(self): - return type(self).__next__(self) - - callable = callable -_add_doc(get_unbound_function, - """Get the function out of a possibly unbound function""") - - -get_method_function = operator.attrgetter(_meth_func) -get_method_self = operator.attrgetter(_meth_self) -get_function_closure = operator.attrgetter(_func_closure) -get_function_code = operator.attrgetter(_func_code) -get_function_defaults = operator.attrgetter(_func_defaults) -get_function_globals = operator.attrgetter(_func_globals) - - -if PY3: - def iterkeys(d, **kw): - return iter(d.keys(**kw)) - - def itervalues(d, **kw): - return iter(d.values(**kw)) - - def iteritems(d, **kw): - return iter(d.items(**kw)) - - def iterlists(d, **kw): - return iter(d.lists(**kw)) - - viewkeys = operator.methodcaller("keys") - - viewvalues = operator.methodcaller("values") - - viewitems = operator.methodcaller("items") -else: - def iterkeys(d, **kw): - return d.iterkeys(**kw) - - def itervalues(d, **kw): - return d.itervalues(**kw) - - def iteritems(d, **kw): - return d.iteritems(**kw) - - def iterlists(d, **kw): - return d.iterlists(**kw) - - viewkeys = operator.methodcaller("viewkeys") - - viewvalues = operator.methodcaller("viewvalues") - - viewitems = operator.methodcaller("viewitems") - -_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") -_add_doc(itervalues, "Return an iterator over the values of a dictionary.") -_add_doc(iteritems, - "Return an iterator over the (key, value) pairs of a dictionary.") -_add_doc(iterlists, - "Return an iterator over the (key, [values]) pairs of a dictionary.") - - -if PY3: - def b(s): - return s.encode("latin-1") - - def u(s): - return s - unichr = chr - import struct - int2byte = struct.Struct(">B").pack - del struct - byte2int = operator.itemgetter(0) - indexbytes = operator.getitem - iterbytes = iter - import io - StringIO = io.StringIO - BytesIO = io.BytesIO - _assertCountEqual = "assertCountEqual" - if sys.version_info[1] <= 1: - _assertRaisesRegex = "assertRaisesRegexp" - _assertRegex = "assertRegexpMatches" - else: - _assertRaisesRegex = "assertRaisesRegex" - _assertRegex = "assertRegex" -else: - def b(s): - return s - # Workaround for standalone backslash - - def u(s): - return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape") - unichr = unichr - int2byte = chr - - def byte2int(bs): - return ord(bs[0]) - - def indexbytes(buf, i): - return ord(buf[i]) - iterbytes = functools.partial(itertools.imap, ord) - import StringIO - StringIO = BytesIO = StringIO.StringIO - _assertCountEqual = "assertItemsEqual" - _assertRaisesRegex = "assertRaisesRegexp" - _assertRegex = "assertRegexpMatches" -_add_doc(b, """Byte literal""") -_add_doc(u, """Text literal""") - - -def assertCountEqual(self, *args, **kwargs): - return getattr(self, _assertCountEqual)(*args, **kwargs) - - -def assertRaisesRegex(self, *args, **kwargs): - return getattr(self, _assertRaisesRegex)(*args, **kwargs) - - -def assertRegex(self, *args, **kwargs): - return getattr(self, _assertRegex)(*args, **kwargs) - - -if PY3: - exec_ = getattr(moves.builtins, "exec") - - def reraise(tp, value, tb=None): - if value is None: - value = tp() - if value.__traceback__ is not tb: - raise value.with_traceback(tb) - raise value - -else: - def exec_(_code_, _globs_=None, _locs_=None): - """Execute code in a namespace.""" - if _globs_ is None: - frame = sys._getframe(1) - _globs_ = frame.f_globals - if _locs_ is None: - _locs_ = frame.f_locals - del frame - elif _locs_ is None: - _locs_ = _globs_ - exec("""exec _code_ in _globs_, _locs_""") - - exec_("""def reraise(tp, value, tb=None): - raise tp, value, tb -""") - - -if sys.version_info[:2] == (3, 2): - exec_("""def raise_from(value, from_value): - if from_value is None: - raise value - raise value from from_value -""") -elif sys.version_info[:2] > (3, 2): - exec_("""def raise_from(value, from_value): - raise value from from_value -""") -else: - def raise_from(value, from_value): - raise value - - -print_ = getattr(moves.builtins, "print", None) -if print_ is None: - def print_(*args, **kwargs): - """The new-style print function for Python 2.4 and 2.5.""" - fp = kwargs.pop("file", sys.stdout) - if fp is None: - return - - def write(data): - if not isinstance(data, basestring): - data = str(data) - # If the file has an encoding, encode unicode with it. - if (isinstance(fp, file) and - isinstance(data, unicode) and - fp.encoding is not None): - errors = getattr(fp, "errors", None) - if errors is None: - errors = "strict" - data = data.encode(fp.encoding, errors) - fp.write(data) - want_unicode = False - sep = kwargs.pop("sep", None) - if sep is not None: - if isinstance(sep, unicode): - want_unicode = True - elif not isinstance(sep, str): - raise TypeError("sep must be None or a string") - end = kwargs.pop("end", None) - if end is not None: - if isinstance(end, unicode): - want_unicode = True - elif not isinstance(end, str): - raise TypeError("end must be None or a string") - if kwargs: - raise TypeError("invalid keyword arguments to print()") - if not want_unicode: - for arg in args: - if isinstance(arg, unicode): - want_unicode = True - break - if want_unicode: - newline = unicode("\n") - space = unicode(" ") - else: - newline = "\n" - space = " " - if sep is None: - sep = space - if end is None: - end = newline - for i, arg in enumerate(args): - if i: - write(sep) - write(arg) - write(end) -if sys.version_info[:2] < (3, 3): - _print = print_ - - def print_(*args, **kwargs): - fp = kwargs.get("file", sys.stdout) - flush = kwargs.pop("flush", False) - _print(*args, **kwargs) - if flush and fp is not None: - fp.flush() - -_add_doc(reraise, """Reraise an exception.""") - -if sys.version_info[0:2] < (3, 4): - def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, - updated=functools.WRAPPER_UPDATES): - def wrapper(f): - f = functools.wraps(wrapped, assigned, updated)(f) - f.__wrapped__ = wrapped - return f - return wrapper -else: - wraps = functools.wraps - - -def with_metaclass(meta, *bases): - """Create a base class with a metaclass.""" - # This requires a bit of explanation: the basic idea is to make a dummy - # metaclass for one level of class instantiation that replaces itself with - # the actual metaclass. - class metaclass(meta): - - def __new__(cls, name, this_bases, d): - return meta(name, bases, d) - return type.__new__(metaclass, 'temporary_class', (), {}) - - -def add_metaclass(metaclass): - """Class decorator for creating a class with a metaclass.""" - def wrapper(cls): - orig_vars = cls.__dict__.copy() - slots = orig_vars.get('__slots__') - if slots is not None: - if isinstance(slots, str): - slots = [slots] - for slots_var in slots: - orig_vars.pop(slots_var) - orig_vars.pop('__dict__', None) - orig_vars.pop('__weakref__', None) - return metaclass(cls.__name__, cls.__bases__, orig_vars) - return wrapper - - -def python_2_unicode_compatible(klass): - """ - A decorator that defines __unicode__ and __str__ methods under Python 2. - Under Python 3 it does nothing. - - To support Python 2 and 3 with a single code base, define a __str__ method - returning text and apply this decorator to the class. - """ - if PY2: - if '__str__' not in klass.__dict__: - raise ValueError("@python_2_unicode_compatible cannot be applied " - "to %s because it doesn't define __str__()." % - klass.__name__) - klass.__unicode__ = klass.__str__ - klass.__str__ = lambda self: self.__unicode__().encode('utf-8') - return klass - - -# Complete the moves implementation. -# This code is at the end of this module to speed up module loading. -# Turn this module into a package. -__path__ = [] # required for PEP 302 and PEP 451 -__package__ = __name__ # see PEP 366 @ReservedAssignment -if globals().get("__spec__") is not None: - __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable -# Remove other six meta path importers, since they cause problems. This can -# happen if six is removed from sys.modules and then reloaded. (Setuptools does -# this for some reason.) -if sys.meta_path: - for i, importer in enumerate(sys.meta_path): - # Here's some real nastiness: Another "instance" of the six module might - # be floating around. Therefore, we can't use isinstance() to check for - # the six meta path importer, since the other six instance will have - # inserted an importer with different class. - if (type(importer).__name__ == "_SixMetaPathImporter" and - importer.name == __name__): - del sys.meta_path[i] - break - del i, importer -# Finally, add the importer to the meta path import hook. -sys.meta_path.append(_importer) diff --git a/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py b/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py index 8927f264a..869257f9c 100644 --- a/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py +++ b/mlxtend/feature_selection/tests/test_exhaustive_feature_selector.py @@ -4,7 +4,6 @@ # # License: BSD 3 clause -import sys import numpy as np import pandas as pd from distutils.version import LooseVersion as Version @@ -32,12 +31,12 @@ def dict_compare_utility(d1, d2): assert d1[i]['feature_names'] == d2[i]["feature_names"], err_msg2 assert_almost_equal(d1[i]['avg_score'], d2[i]['avg_score'], - decimal=3, + decimal=2, err_msg=("d1[%s]['avg_score']" " != d2[%s]['avg_score']" % (i, i))) assert_almost_equal(d1[i]['cv_scores'], d2[i]['cv_scores'], - decimal=3, + decimal=2, err_msg=("d1[%s]['cv_scores']" " != d2[%s]['cv_scores']" % (i, i))) @@ -160,22 +159,27 @@ def test_knn_cv3(): cv=4, print_progress=False) efs1 = efs1.fit(X, y) - expect = {0: {'avg_score': 0.9391025641025641, + expect = {0: {'avg_score': 0.9329658605974395, 'feature_idx': (0, 1, 2), 'feature_names': ('0', '1', '2'), - 'cv_scores': np.array([0.974, 0.947, 0.892, 0.946])}, + 'cv_scores': np.array([0.974, 0.947, 0.892, 0.919])}, 1: {'avg_score': 0.9400782361308677, 'feature_idx': (0, 1, 3), 'feature_names': ('0', '1', '3'), 'cv_scores': np.array([0.921, 0.947, 0.919, 0.973])}, - 2: {'avg_score': 0.95299145299145294, + 2: {'avg_score': 0.9532361308677098, 'feature_idx': (0, 2, 3), 'feature_names': ('0', '2', '3'), 'cv_scores': np.array([0.974, 0.947, 0.919, 0.973])}, 3: {'avg_score': 0.97275641025641035, 'feature_idx': (1, 2, 3), 'feature_names': ('1', '2', '3'), - 'cv_scores': np.array([0.974, 1. , 0.946, 0.973])}} + 'cv_scores': np.array([0.974, 1., 0.946, 0.973])}} + + if Version(sklearn_version) < Version("1.0"): + expect[0]['avg_score'] = 0.9391025641025641 + expect[0]['cv_scores'] = np.array([0.974, 0.947, 0.892, 0.946]) + expect[2]['avg_score'] = 0.9529914529914529 if Version(sklearn_version) < Version("0.22"): expect[0]['cv_scores'] = np.array([0.97435897, 0.94871795, diff --git a/mlxtend/feature_selection/tests/test_sequential_feature_selector.py b/mlxtend/feature_selection/tests/test_sequential_feature_selector.py index 8cdaad309..0d3849729 100644 --- a/mlxtend/feature_selection/tests/test_sequential_feature_selector.py +++ b/mlxtend/feature_selection/tests/test_sequential_feature_selector.py @@ -199,8 +199,8 @@ def test_knn_cv3(): verbose=0) sfs1 = sfs1.fit(X, y) sfs1.subsets_ - expect = {1: {'avg_score': 0.95299145299145294, - 'cv_scores': np.array([0.974, 0.947, 0.892, 1.]), + expect = {1: {'avg_score': 0.9599928876244666, + 'cv_scores': np.array([0.974, 0.947, 0.919, 1.]), 'feature_idx': (3,)}, 2: {'avg_score': 0.95993589743589736, 'cv_scores': np.array([0.974, 0.947, 0.919, 1.]), @@ -209,6 +209,10 @@ def test_knn_cv3(): 'cv_scores': np.array([0.974, 1., 0.946, 0.973]), 'feature_idx': (1, 2, 3)}} + if Version(sklearn_version) < Version("1.0"): + expect[1]['avg_score'] = 0.95299145299145294 + expect[1]['cv_scores'] = np.array([0.974, 0.947, 0.892, 1.]), + if Version(sklearn_version) < Version("0.22"): expect[1]['cv_scores'] = np.array([0.97435897, 0.94871795, diff --git a/mlxtend/frequent_patterns/association_rules.py b/mlxtend/frequent_patterns/association_rules.py index e4bb532e2..d6b763be7 100644 --- a/mlxtend/frequent_patterns/association_rules.py +++ b/mlxtend/frequent_patterns/association_rules.py @@ -76,6 +76,9 @@ def association_rules(df, metric="confidence", http://rasbt.github.io/mlxtend/user_guide/frequent_patterns/association_rules/ """ + if not df.shape[0]: + raise ValueError('The input DataFrame `df` containing ' + 'the frequent itemsets is empty.') # check for mandatory columns if not all(col in df.columns for col in ["support", "itemsets"]): diff --git a/mlxtend/frequent_patterns/tests/test_association_rules.py b/mlxtend/frequent_patterns/tests/test_association_rules.py index c841f6b5f..9e0945aa2 100644 --- a/mlxtend/frequent_patterns/tests/test_association_rules.py +++ b/mlxtend/frequent_patterns/tests/test_association_rules.py @@ -1,5 +1,6 @@ import numpy as np import pandas as pd +import pytest from mlxtend.frequent_patterns import apriori, association_rules from numpy.testing import assert_raises as numpy_assert_raises @@ -224,3 +225,9 @@ def test_on_df_with_missing_entries_support_only(): assert df_result['support'].shape == (18,) assert int(np.isnan(df_result['support'].values).any()) != 1 + + +def test_with_empty_dataframe(): + df = df_freq_items_with_colnames.iloc[:0] + with pytest.raises(ValueError): + association_rules(df) diff --git a/mlxtend/plotting/heatmap.py b/mlxtend/plotting/heatmap.py index 591f53b45..527f8806a 100644 --- a/mlxtend/plotting/heatmap.py +++ b/mlxtend/plotting/heatmap.py @@ -114,7 +114,8 @@ def heatmap(matrix, s=cell_text, va='center', ha='center', - color="white" if normed_matrix[i, j] < 0.5 + color="white" if + normed_matrix[i, j] > np.max(normed_matrix)/2 else "black") if row_names is not None: diff --git a/mlxtend/utils/base_compostion.py b/mlxtend/utils/base_compostion.py index 922307f2b..cb19aab0e 100644 --- a/mlxtend/utils/base_compostion.py +++ b/mlxtend/utils/base_compostion.py @@ -1,6 +1,5 @@ """Utilties to handle estimator list""" -from ..externals import six from sklearn.utils.metaestimators import _BaseComposition @@ -20,7 +19,7 @@ def _set_params(self, attr, named_attr, **params): if items: names, estimators = zip(*items) estimators = list(estimators) - for name in list(six.iterkeys(params)): + for name in list(params.keys()): if '__' not in name and name in names: # replace single estimator and re-build the # root estimators list diff --git a/setup.cfg b/setup.cfg index 2a9acf13d..ead3fa338 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,2 +1,5 @@ [bdist_wheel] universal = 1 + +[tool:pytest] +norecursedirs = plotting/* image/* \ No newline at end of file