Ha scikit-learn hanno algoritmo di regressione selezione / stepwise in avanti?

Question

sto lavorando sul problema con troppe funzioni e formazione miei modelli prende troppo tempo. Ho implementato algoritmo di selezione in avanti di scegliere caratteristiche.

Comunque, mi chiedevo fa scikit-learn avere selezione avanti / stepwise regressione algoritmo?

Answer 1

No, sklearn non sembra avere un algoritmo di selezione in avanti. Tuttavia, esso fornisce eliminazione funzione ricorsiva, che è un algoritmo greedy eliminazione caratteristica simile alla selezione sequenziale all'indietro. Vedere la documentazione qui:

http://scikit-learn.org/stable/modules/generated/sklearn .feature_selection.RFE.html

Answer 2

Sklearn ha un algoritmo di selezione in avanti, anche se non è detto che nel scikit-learn. Il metodo di selezione funzione chiamata F_regression in scikit-learn volontà sequenzialmente includere caratteristiche che migliorano il modello più, finché ci sono K presenta nel modello (K è un ingresso).

Si inizia con la regressione delle etichette su ciascuna funzione singolarmente, e quindi osservare che caratteristica migliora il modello più usando la statistica F. Poi si incorpora la caratteristica vincente nel modello. Quindi esegue un'iterazione le restanti funzioni per trovare il prossimo film che migliora il modello più, ancora una volta utilizzando il test F-statistica o F. Lo fa fino a quando ci sono K presenta nel modello.

Si noti che le restanti funzioni che sono correlati alle caratteristiche incorporate nel modello probabilmente non sarà selezionato, dal momento che non si correlano con i residui (anche se potrebbe correlano bene con le etichette). Questo aiuta a guardia contro multi-collinearità.

Answer 3

scikit-learn infatti non supporta la regressione graduale. Questo perché ciò che è comunemente noto come 'graduale regressione' è un algoritmo basato su p-valori dei coefficienti di regressione lineare, e scikit-learn volutamente evita approccio inferenziale per l'apprendimento del modello (significatività test, ecc). Inoltre, OLS pura è soltanto uno dei numerosi algoritmi di regressione, e dal punto di vista scikit-learn è né molto importante, né uno dei migliori.

Ci sono, tuttavia, alcuni pezzi di consulenza per coloro che hanno ancora bisogno di un buon modo per la selezione funzione con modelli lineari:

1. Usare modelli intrinsecamente sparse come ElasticNet o Lasso.
2. normalizza la vostra caratteristiche con StandardScaler, e poi ordinare le vostre caratteristiche semplicemente model.coef_. Per covariate perfettamente indipendenti è equivalente a ordinamento per valori p. Il sklearn.feature_selection.RFE classe lo farà per voi, e RFECV sarà anche valutare il numero ottimale di funzionalità.
3. un attuazione della selezione in avanti per regolare $ R ^ 2 $ che funziona con statsmodels.
4. Do forza bruta in avanti o all'indietro selezione per massimizzare il vostro preferito metrica convalida incrociata (che potrebbe richiedere tempo di circa quadratica in numero di covariate). Uno scikit-learn pacchetto mlxtend compatibile questo approccio per qualsiasi estimatore e qualsiasi metrica .
5. Se si vuole ancora di vaniglia regressione graduale, è più facile per basarlo su statsmodels, dal momento che questo pacchetto calcola valori p per voi. Selezione avanti-indietro di base potrebbe essere la seguente:

`` `

from sklearn.datasets import load_boston
import pandas as pd
import numpy as np
import statsmodels.api as sm

data = load_boston()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target


def stepwise_selection(X, y, 
                       initial_list=[], 
                       threshold_in=0.01, 
                       threshold_out = 0.05, 
                       verbose=True):
    """ Perform a forward-backward feature selection 
    based on p-value from statsmodels.api.OLS
    Arguments:
        X - pandas.DataFrame with candidate features
        y - list-like with the target
        initial_list - list of features to start with (column names of X)
        threshold_in - include a feature if its p-value < threshold_in
        threshold_out - exclude a feature if its p-value > threshold_out
        verbose - whether to print the sequence of inclusions and exclusions
    Returns: list of selected features 
    Always set threshold_in < threshold_out to avoid infinite looping.
    See https://en.wikipedia.org/wiki/Stepwise_regression for the details
    """
    included = list(initial_list)
    while True:
        changed=False
        # forward step
        excluded = list(set(X.columns)-set(included))
        new_pval = pd.Series(index=excluded)
        for new_column in excluded:
            model = sm.OLS(y, sm.add_constant(pd.DataFrame(X[included+[new_column]]))).fit()
            new_pval[new_column] = model.pvalues[new_column]
        best_pval = new_pval.min()
        if best_pval < threshold_in:
            best_feature = new_pval.argmin()
            included.append(best_feature)
            changed=True
            if verbose:
                print('Add  {:30} with p-value {:.6}'.format(best_feature, best_pval))

        # backward step
        model = sm.OLS(y, sm.add_constant(pd.DataFrame(X[included]))).fit()
        # use all coefs except intercept
        pvalues = model.pvalues.iloc[1:]
        worst_pval = pvalues.max() # null if pvalues is empty
        if worst_pval > threshold_out:
            changed=True
            worst_feature = pvalues.argmax()
            included.remove(worst_feature)
            if verbose:
                print('Drop {:30} with p-value {:.6}'.format(worst_feature, worst_pval))
        if not changed:
            break
    return included

result = stepwise_selection(X, y)

print('resulting features:')
print(result)

Questo esempio potrebbe stampare il seguente output:

Add  LSTAT                          with p-value 5.0811e-88
Add  RM                             with p-value 3.47226e-27
Add  PTRATIO                        with p-value 1.64466e-14
Add  DIS                            with p-value 1.66847e-05
Add  NOX                            with p-value 5.48815e-08
Add  CHAS                           with p-value 0.000265473
Add  B                              with p-value 0.000771946
Add  ZN                             with p-value 0.00465162
resulting features:
['LSTAT', 'RM', 'PTRATIO', 'DIS', 'NOX', 'CHAS', 'B', 'ZN']

Answer 4

In realtà c'è un algoritmo bella chiamata "Forward_Select" che utilizza Statsmodels e consente di impostare la propria metrica (AIC, BIC, Adjusted-R-Squared, o come preferite) per aggiungere progressivamente una variabile al modello. L'algoritmo può essere trovato nella sezione commenti di questa pagina -. Scorrere verso il basso e vedrete che nella parte inferiore della pagina

https://planspace.org/20150423-forward_selection_with_statsmodels/

Vorrei aggiungere che l'algoritmo ha anche una bella caratteristica: si può applicare a entrambi problemi di classificazione o di regressione! Devi solo raccontarla.

Provalo e vedere di persona.

Answer 5

In realtà sklearn non dispone di un algoritmo di selezione in avanti, il pensiero di un href="https://github.com/scikit-learn/scikit-learn/pull/8684" rel="nofollow noreferrer"> richiesta di pull con un'implementazione di forward attese di selezione funzione nel scikit-learn repository dal aprile 2017.

In alternativa, c'è avanti ed uno step-ahead selezione indietro in mlxtend . Lo si può trovare del documento sequenziale Selettore Caratteristica