Metodi di insieme: tecniche eleganti per produrre risultati di apprendimento automatico migliorati

metodi di ensemble sono tecniche che creano più modelli e poi combinarli per produrre risultati migliori. metodi di ensemble di solito produce soluzioni più preciso di un unico modello avrebbe fatto. Questo è stato il caso in un certo numero di concorsi machine learning, in cui le soluzioni vincenti utilizzati metodi di ensemble. Nel popolare concorso Netflix, il vincitore utilizzato un metodo complesso per implementare un potente algoritmo di filtraggio collaborativo. Un altro esempio è KDD 2009, dove il vincitore utilizzato anche metodi di ensemble. È inoltre possibile trovare i vincitori che hanno usato questi metodi in concorsi Kaggle, ad esempio Ecco l'intervista con il vincitore del concorso CrowdFlower.

E 'importante che noi comprendiamo alcune terminologie prima di continuare con questo articolo. In tutto l'articolo che ho usato il termine “modello” per descrivere l'uscita del algoritmo che allenato con i dati. Questo modello viene poi utilizzato per fare previsioni. Questo algoritmo può essere un qualsiasi algoritmo di apprendimento della macchina, come la regressione logistica, albero di decisione, ecc Questi modelli, quando viene utilizzato come input di metodi di ensemble, sono chiamati “modelli base”.

In questo post del blog mi occuperò di metodi di ensemble per la classificazione e descrivere alcuni metodi ampiamente noti di Ensemble: voto, accatastamento, insaccamento e aumentando.

Votare e una media di metodi basati Ensemble

Voto e media sono due dei più facili metodi di ensemble. Entrambi sono facili da capire e da attuare. Le votazioni viene utilizzato per la classificazione e la media viene utilizzata per la regressione.

In entrambi i metodi, il primo passo è quello di creare più modelli di classificazione / regressione utilizzando alcuni dati di addestramento. Ogni modello base può essere creato utilizzando diverse fessure della stessa dati di addestramento e stesso algoritmo, o utilizzando lo stesso insieme di dati con algoritmi diversi, o qualsiasi altro metodo. Pseudocodice seguente mostra pitone campionature l'uso degli stessi dati di addestramento con algoritmi differenti.

 train = load_csv("train.csv") target = train["target"] train = train.drop("target") test = load_csv("test.csv") algorithms = [logistic_regression, decision_tree_classification, ...] #for classification algorithms = [linear_regression, decision_tree_regressor, ...] #for regression predictions = matrix(row_length=len(target), column_length=len(algorithms)) for i,algorithm in enumerate(algorithms): predictions[,i] = algorithm.fit(train, target).predict(test)

Secondo il pseudocodice sopra, abbiamo creato previsioni per ciascun modello e salvati in una matrice chiamata predizioni dove ogni colonna contiene le previsioni di un modello.

voto a maggioranza

Ogni modello fa una previsione (utili) per ogni istanza di prova e la previsione output finale è quella che riceve più di metà dei voti. Se nessuna delle previsioni ottenere più della metà dei voti, possiamo dire che il metodo insieme non poteva fare una previsione stabile per questa istanza. Anche se questa è una tecnica ampiamente utilizzata, si può provare il più votato previsione (anche se questo è meno della metà dei voti), come la previsione finale. In alcuni articoli, è possibile visualizzare questo metodo che si chiama “voto di pluralità”.

voto ponderato

A differenza di voto a maggioranza, in cui ogni modello ha gli stessi diritti, siamo in grado di aumentare l'importanza di uno o più modelli. Nel voto ponderato si conta la previsione dei modelli migliori più volte. Trovare un insieme ragionevole di pesi dipende da voi.

della media semplice

In semplice metodo di media, per ogni istanza di prova set di dati, le previsioni medi sono calcolati. Questo metodo spesso riduce sovradattamento e crea un modello di regressione più liscia. Il codice seguente pseudocodice mostra questo semplice metodo di media:

 final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]) )

della media ponderata

media ponderata è una versione leggermente modificata di media semplice, dove la previsione di ciascun modello è moltiplicato per il peso e quindi la loro media viene calcolata. Il codice seguente pseudocodice illustra la media ponderata:

 weights = [..., ..., ...] #length is equal to len(algorithms) final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]*weights) )

Impilabile più modelli Machine Learning

Impilabili, noto anche come generalizzazione impilati, è un metodo complesso dove i modelli vengono combinati utilizzando un altro algoritmo di apprendimento automatico. L'idea di base è quella di formare algoritmi di apprendimento automatico con dati di addestramento e quindi generare un nuovo insieme di dati con questi modelli. Allora questo nuovo set di dati viene utilizzato come input per l'algoritmo di apprendimento automatico combinatore.

Il pseudocodice di una procedura di accatastamento è riassunta come segue:

 base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): stacking_train_dataset[,i] = base_algorithm.fit(train, target).predict(train) stacking_test_dataset[,i] = base_algorithm.predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Come si può vedere nel pseudocodice sopra, di dati di addestramento per l'algoritmo combinatore viene generata utilizzando le uscite degli algoritmi di base. Nel pseudocodice, l'algoritmo di base viene generato utilizzando dati di addestramento e poi lo stesso insieme di dati viene utilizzata di nuovo per fare previsioni. Ma, come sappiamo, nel mondo reale non usiamo lo stesso insieme di dati di formazione per la previsione, in modo per superare questo problema si possono vedere alcune implementazioni di accatastamento in cui dati di addestramento è diviso. Qui sotto potete vedere un pseudocodice in cui il set di dati di formazione è suddiviso prima di allenare gli algoritmi di base:

 base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): for trainix, testix in split(train, k=10): #you may use sklearn.cross_validation.KFold of sklearn library stacking_train_dataset[testcv,i] = base_algorithm.fit(train[trainix], target[trainix]).predict(train[testix]) stacking_test_dataset[,i] = base_algorithm.fit(train).predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

bootstrap Aggregare

Il nome Bootstrap di aggregazione, noto anche come “insaccamento”, riassume gli elementi chiave di questa strategia. Nell'algoritmo insaccamento, il primo passo comporta la creazione di modelli multipli. Questi modelli sono generati utilizzando lo stesso algoritmo con casuali sottocampioni di set di dati, redatti dall'insieme di dati originale casualmente con metodo di campionamento bootstrap. Nel campionamento bootstrap, alcuni esempi originali appaiono più di una volta e alcuni esempi originali non sono presenti nel campione. Se si desidera creare un sub-set di dati con m elementi, è necessario selezionare un elemento casuale dai tempi originali set di dati m. E se l'obiettivo è la generazione di n set di dati, si segue questo passo n volte.

Alla fine, abbiamo n insiemi di dati in cui il numero di elementi in ogni insieme di dati è m. Il seguente pitone campionature campionamento pseudocodice mostra bootstrap:

 def bootstrap_sample(original_dataset, m): sub_dataset = [] for i in range(m): sub_dataset.append( random_one_element(original_dataset) ) return sub_dataset

Il secondo passo insacco sta aggregando i modelli generati. metodi ben noti, come il voto e media, sono utilizzati per questo scopo.

L'aspetto pseudocodice generale come questa:

 def bagging(n, m, base_algorithm, train_dataset, target, test_dataset): predictions = matrix(row_length=len(target), column_length=n) for i in range(n): sub_dataset = bootstrap_sample(train_dataset, m) predictions[,i] = base_algorithm.fit(original_dataset, target).predict(test_dataset) final_predictions = voting(predictions) # for classification final_predictions = averaging(predictions) # for regression return final_predictions

In insaccamento, ogni sotto-campioni possono essere generati in modo indipendente l'uno dall'altro. Così la generazione e la formazione possono essere condotti in parallelo.

È inoltre possibile trovare attuazione della strategia di insaccamento in alcuni algoritmi. Ad esempio, a caso Foresta algoritmo utilizza la tecnica di insaccatura con alcune differenze. Foresta a caso utilizza funzionalità di selezione casuale, e l'algoritmo di base di esso è un algoritmo di albero decisionale.

Aumentare: Conversione di modelli debole per quelli forti

Il termine “potenziamento” è usato per descrivere una famiglia di algoritmi in grado di convertire i modelli deboli a modelli forti. Il modello è debole se ha un tasso di errore sostanziale, ma la prestazione non è casuale (determinando un tasso di errore di 0,5 per la classificazione binaria). Aumentando gradualmente costruisce un insieme formando ogni modello con gli stessi dati, ma dove i pesi di istanze vengono regolati secondo l'errore dell'ultimo predizione. L'idea principale sta costringendo i modelli di concentrarsi sui casi che sono difficili. A differenza di insaccamento, aumentando è un metodo sequenziale, e quindi non è possibile utilizzare le operazioni parallele qui.

La procedura generale dell'algoritmo potenziamento è definito come segue:

 def adjust_dataset(_train, errors): #create a new dataset by using the hardest instances ix = get_highest_errors_index(train) return concat(_train[ix], random_select(train)) models = [] _train = random_select(train) for i in range(n): #n rounds model = base_algorithm.fit(_train) predictions = model.predict(_train) models.append(model) errors = calculate_error(predictions) _train = adjust_dataset(_train, errors) final_predictions = combine(models, test)

La funzione adjust_dataset restituisce un nuovo insieme di dati contenente i casi più difficili, che possono poi essere utilizzati per forzare l'algoritmo di base da cui imparare.

AdaBoost è un algoritmo noto che è un metodo di amplificazione. I fondatori della AdaBoost ha vinto il Premio Gödel per il loro lavoro. Per lo più, l'algoritmo albero decisionale è preferito come un algoritmo di base per AdaBoost e nella biblioteca sklearn l'algoritmo di base predefinita per AdaBoost è albero di decisione (AdaBoostRegressor e AdaBoostClassifier). Come discusso nel paragrafo precedente, lo stesso metodo incrementale vale per AdaBoost. Le informazioni raccolte ad ogni passo dell'algoritmo AdaBoost circa la 'durezza' di ogni campione di training viene alimentato nel modello. Il 'insieme di dati di regolazione' passo è diverso da quello sopra descritto e passo le 'conciliano modelli' viene calcolato utilizzando voto ponderato.

Conclusione

Anche se i metodi di ensemble possono aiutare a vincere concorsi di machine learning elaborando algoritmi sofisticati e producendo risultati con elevata precisione, spesso non è preferito nelle industrie dove interpretabilità è più importante. Tuttavia, l'efficacia di questi metodi sono innegabili, e le loro prestazioni nelle applicazioni appropriate può essere enorme. In settori come la sanità, anche la più piccola quantità di miglioramento della precisione di algoritmi di apprendimento automatico può essere qualcosa di veramente prezioso.