Se sei un esperto del settore del machine learning, probabilmente sei già a conoscenza del fatto che la scelta della migliore pipeline di modelli di machine learning per un set di dati può essere una vera sfida. Inoltre, spesso questo processo richiede un intervento manuale che richiede molte ore di lavoro. Ma cosa succederebbe se ti dicessi che c'è un modo per automatizzare questo processo?
Gli esperti sanno che spesso la ricerca della migliore pipeline di modelli può essere come cercare un ago in un pagliaio
Beh, c'è! È chiamato AutoML e fornisce strumenti che permettono di rilevare automaticamente buone pipeline di modelli di machine learning per un set di dati, con un intervento minimo da parte dell'utente.
L'utilizzo di AutoML è particolarmente adatto agli esperti di dominio che non hanno una conoscenza approfondita dell'apprendimento automatico, ma anche per i professionisti dell'apprendimento automatico che cercano di ottenere rapidamente buoni risultati per un'attività di modellazione predittiva.
Fortunatamente, esistono librerie open source disponibili per l'utilizzo di metodi AutoML con librerie di machine learning popolari in Python, come la libreria di machine learning scikit-learn. In questo tutorial ti mostrerò come utilizzare le migliori librerie AutoML open source per scikit-learn in Python, in modo da poter sfruttare al massimo le potenzialità di AutoML.
Dopo aver completato questo tutorial, sarai in grado di scoprire come utilizzare le tecniche di AutoML per scoprire automaticamente e rapidamente una pipeline di modelli di machine learning con buone prestazioni per un'attività di modellazione predittiva. Inoltre, scoprirai le tre librerie AutoML più popolari per Scikit-Learn: Hyperopt-Sklearn, Auto-Sklearn e TPOT. Sarai in grado di utilizzare queste librerie per scoprire modelli con buone prestazioni per attività di modellazione predittiva in Python.
Insomma, se vuoi scoprire come utilizzare AutoML per semplificare il processo di modellazione predittiva e ottenere risultati migliori e più veloci, questo tutorial è quello che fa per te. Quindi, senza ulteriori indugi, iniziamo!
Indice su AutoML : le migliori librerie python
Questo tutorial è diviso in quattro parti; sono:
Machine learning automatizzato
Sei alla ricerca di un modo semplice e veloce per creare modelli di machine learning predittivi? Allora AutoML potrebbe essere la soluzione che fa per te! Questa tecnologia innovativa consente di selezionare automaticamente la preparazione dei dati, il modello di machine learning e gli iperparametri del modello, senza richiedere alcuna conoscenza specifica in materia.
In pratica, basta fornire i dati di input e il sistema di AutoML si occuperà di tutto il resto, individuando l'approccio migliore per l'applicazione specifica. Grazie a questa tecnologia all'avanguardia, persino gli scienziati di dominio che non hanno conoscenze approfondite in materia di machine learning potranno accedere a questo campo in modo semplice e intuitivo.
Inoltre, non c'è bisogno di creare da zero una pipeline di modelli: molte aziende offrono servizi di AutoML preconfezionati, che consentono di scaricare o utilizzare online una pipeline già pronta all'uso. Google, Microsoft e Amazon sono solo alcuni esempi di aziende che offrono questa opzione.
Ma non solo: esistono anche numerose librerie open source che implementano le tecniche di AutoML, offrendo l'opportunità di personalizzare le trasformazioni dei dati, i modelli e gli iperparametri in modo specifico per le tue esigenze. In particolare, tre librerie si sono distinte come le migliori del settore: Hyperopt-Sklearn, Auto-Sklearn e TPOT.
Se hai una libreria preferita che non compare in questa lista, condividila con noi nei commenti qui sotto. Pronto a scoprire il mondo di AutoML? Continua a leggere per tutte le informazioni necessarie!
Auto Sklearn
Auto-Sklearn è una libreria open source di AutoML in Python che utilizza modelli di machine learning della libreria scikit-learn.
La libreria è stata sviluppata da Matthias Feurer et al. e descritta nel loro documento del 2015 intitolato "Efficient and Robust Automated Machine Learning".
In questo documento, viene introdotto un nuovo e robusto sistema AutoML basato su scikit-learn, che utilizza 15 classificatori, 14 metodi di pre-elaborazione delle caratteristiche e 4 metodi di pre-elaborazione dei dati. Ciò porta a uno spazio di ipotesi strutturato con 110 iperparametri.
Il primo passo è installare la libreria Auto-Sklearn utilizzando pip come segue:
Dopo aver installato la libreria, è possibile importarla e stampare il numero di versione per confermare l'installazione corretta:
# Stampa la versione di Auto-Sklearn
import autosklearn
print('autosklearn: %s' % autosklearn.__version__)
Eseguendo questo esempio, verrà stampato il numero di versione, che dovrebbe essere uguale o superiore a 0.6.0.
Successivamente, è possibile dimostrare l'utilizzo di Auto-Sklearn su un dataset di classificazione sintetico.
In questo esempio, viene definita una classe AutoSklearnClassifier che controlla la ricerca e la configurazione per una durata massima di due minuti (120 secondi), uccidendo ogni singolo modello la cui valutazione richiede più di 30 secondi. Al termine dell'esecuzione, le statistiche della ricerca sono riportate e il modello con le migliori prestazioni è valutato su un set di dati di controllo.
Ecco l'esempio completo:
# Esempio di auto-sklearn su un dataset di classificazione
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from autosklearn.classification import AutoSklearnClassifier
# Definizione del dataset
X, y = make_classification(n_samples=100, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# Suddivisione in set di training e test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# Definizione della ricerca
model = AutoSklearnClassifier(time_left_for_this_task=2*60, per_run_time_limit=30, n_jobs=8)
# Esecuzione della ricerca
model.fit(X_train, y_train)
# Statistiche della ricerca
print(model.sprint_statistics())
# Valutazione del miglior modello
y_hat = model.predict(X_test)
acc = accuracy_score(y_test, y_hat)
print("Accuracy: %.3f" % acc)
L'esecuzione di questo esempio richiederà circa due minuti, data la durata massima di esecuzione impostata.
Alla fine dell'esecuzione, verrà stampato un riepilogo che mostra che sono stati valutati 599 modelli e che le prestazioni stimate del modello finale sono state del 95,6%.
auto-sklearn results:Dataset
name: 771625f7c0142be6ac52bcd108459927
Metric: accuracy
Best validation score: 0.956522
Number of target algorithm runs: 653
Number of successful target algorithm runs: 599
Number of crashed target algorithm runs: 54
Number of target algorithms that exceeded the time limit: 0
Number of target algorithms that exceeded the memory limit: 0Quindi valutiamo il modello sul set di dati di controllo e vediamo che è stata raggiunta un'accuratezza di classificazione del 97 percento, che è ragionevolmente abile.
Accuracy: 0.970Strumento di ottimizzazione della pipeline basato su albero (TPOT)
TPOT (Tree-based Pipeline Optimization Tool) è una libreria Python che utilizza un algoritmo evolutivo per progettare e ottimizzare automaticamente le pipeline di machine learning. La pipeline è rappresentata da una struttura ad albero e include algoritmi per la preparazione e la modellazione dei dati, nonché gli iperparametri del modello.
Per utilizzare TPOT, la libreria deve essere installata utilizzando pip come segue:
!pip install tpot
Una volta installata, è possibile importare la libreria e verificare la versione installata come segue:
import tpot
print(f"tpot: {tpot.__version__}")
L'utilizzo di TPOT per una classificazione sintetica può essere dimostrato con il seguente esempio:
from sklearn.datasets import make_classification
from sklearn.model_selection import RepeatedStratifiedKFold
from tpot import TPOTClassifier
# definisci dataset
X, y = make_classification(n_samples=100, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# definisci model evaluation
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# definisci ricerca
model = TPOTClassifier(generations=5, population_size=50, cv=cv, scoring='accuracy', verbosity=2, random_state=1, n_jobs=-1)
# esegui la ricerca
model.fit(X, y)
# esporta il miglior modello
model.export('tpot_best_model.py')
L'esecuzione dell'esempio potrebbe richiedere alcuni minuti e verrà visualizzata una barra di avanzamento sulla riga di comando.
L'accuratezza dei modelli con le migliori prestazioni verrà segnalata lungo il percorso.
I risultati specifici varieranno data la natura stocastica della procedura di ricerca. In questo caso, la pipeline con le migliori prestazioni ha raggiunto una precisione media di circa il 92,6%, come indicato di seguito:
Generation 1 - Current best internal CV score: 0.9166666666666666
Generation 2 - Current best internal CV score: 0.9166666666666666
Generation 3 - Current best internal CV score: 0.9266666666666666
Generation 4 - Current best internal CV score: 0.9266666666666666
Generation 5 - Current best internal CV score: 0.9266666666666666
Best pipeline: ExtraTreesClassifier(input_matrix, bootstrap=False, criterion=gini, max_features=0.35000000000000003, min_samples_leaf=2, min_samples_split=6, n_estimators=100)
Il miglior modello viene salvato in un file denominato "tpot_best_model.py".
Il codice nel file "tpot_best_model.py" può essere utilizzato per adattare la pipeline su un set di dati specifico.
La pipeline con le migliori prestazioni viene quindi salvata in un file denominato
" tpot_best_model.py ".
import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.model_selection import train_test_split
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=1)
# Average CV score on the training set was: 0.9266666666666666
exported_pipeline = ExtraTreesClassifier(bootstrap=False, criterion="gini", max_features=0.35000000000000003, min_samples_leaf=2, min_samples_split=6, n_estimators=100)
# Fix random state in exported estimator
if hasattr(exported_pipeline, 'random_state'):
setattr(exported_pipeline, 'random_state', 1)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
È quindi possibile recuperare il codice per la creazione della pipeline del modello e integrarlo nel progetto.
Hyperopt-Sklearn
HyperOpt è una libreria Python open source per l'ottimizzazione bayesiana sviluppata da James Bergstra. È progettato per l'ottimizzazione su larga scala per modelli con centinaia di parametri e consente di ridimensionare la procedura di ottimizzazione su più core e più macchine.
HyperOpt-Sklearn contiene la li breria HyperOpt e consente la ricerca automatica di metodi di preparazione dei dati, algoritmi di apprendimento automatico e iperparametri del modello per attività di classificazione e regressione.
Ora che abbiamo familiarità con HyperOpt e HyperOpt-Sklearn, diamo un'occhiata a come utilizzare HyperOpt-Sklearn.
Il primo passo è installare la libreria HyperOpt.
Ciò può essere ottenuto utilizzando il gestore di pacchetti pip come segue:
sudo pip install hyperopt
Successivamente, dobbiamo installare la libreria HyperOpt-Sklearn. Anche questo può essere installato utilizzando pip, anche se dobbiamo eseguire questa operazione manualmente clonando il repository ed eseguendo l'installazione dai file locali, come segue:
git clone git@github.com:hyperopt/hyperopt-sklearn.git
cd hyperopt-sklearn
sudo pip install .
cd ..
Possiamo confermare che l'installazione è andata a buon fine controllando il numero di versione con il seguente comando:
sudo pip show hpsklearn
Questo riepilogherà la versione installata di HyperOpt-Sklearn, confermando che viene utilizzata una versione moderna.
Name: hpsklearn
Version: 0.0.3
Summary: Hyperparameter Optimization for sklearn
Home-page: http://hyperopt.github.com/hyperopt-sklearn/
Author: James Bergstra
Author-email: anon@anon.com
License: BSD
Location: ...
Requires: nose, scikit-learn, numpy, scipy, hyperopt
Required-by:
Successivamente, possiamo dimostrare l'utilizzo di Hyperopt-Sklearn su un'attività di classificazione sintetica.
Possiamo configurare un'istanza HyperoptEstimator che esegue la ricerca, inclusi i classificatori da considerare nello spazio di ricerca, i passaggi di pre-elaborazione e l'algoritmo di ricerca da utilizzare. In questo caso, utilizzeremo TPE, o Tree of Parzen Estimators, ed eseguiremo 50 valutazioni. Al termine della ricerca, viene valutata e riepilogata la pipeline del modello più performante.
Di seguito è riportato l'esempio completo utilizzando il formato del codice Python:
# Esempio di Hyperopt-sklearn per un dataset di classificazionefrom sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from hpsklearn import HyperoptEstimator
from hpsklearn import any_classifier
from hpsklearn import any_preprocessing
from hyperopt import tpe
# Definiamo il dataset
X, y = make_classification(n_samples=100, n_features=10, n_informative=5, n_redundant=5, random_state=1)
# Suddividiamo il dataset in set di training e di test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# Definiamo la ricerca
model = HyperoptEstimator(
classifier=any_classifier('cla'),
preprocessing=any_preprocessing('pre'),
algo=tpe.suggest,
max_evals=50,
trial_timeout=30
)
# Eseguiamo la ricerca
model.fit(X_train, y_train)
# Riepiloghiamo le performance
acc = model.score(X_test, y_test)
print("Accuracy: %.3f" % acc)
# Riepiloghiamo il miglior modello
print(model.best_model())Verrà segnalato lo stato di avanzamento della ricerca e verranno visualizzati alcuni avvisi che puoi tranquillamente ignorare.
Al termine dell'esecuzione, il modello con le migliori prestazioni viene valutato sul set di dati di controllo e la pipeline rilevata viene stampata per un uso successivo.
I tuoi risultati specifici potrebbero differire a causa della natura stocastica dell'algoritmo di apprendimento e del processo di ricerca. Prova a eseguire l'esempio alcune volte.
In questo caso, possiamo vedere che il modello scelto ha raggiunto una precisione di circa l'84,8% sul set di test di controllo. La pipeline prevede un modello SGDClassifier senza pre-elaborazione.
Accuracy: 0.848
{'learner': SGDClassifier(alpha=0.0012253733891387925, average=False,
class_weight='balanced', early_stopping=False, epsilon=0.1,
eta0=0.0002555872679483392, fit_intercept=True,
l1_ratio=0.628343459087075, learning_rate='optimal',
loss='perceptron', max_iter=64710625.0, n_iter_no_change=5,
n_jobs=1, penalty='l2', power_t=0.42312829309173644,
random_state=1, shuffle=True, tol=0.0005437535215080966,
validation_fraction=0.1, verbose=False, warm_start=False), 'preprocs': (), 'ex_preprocs': ()}Il modello stampato può quindi essere utilizzato direttamente, ad esempio il codice copiato e incollato in un altro progetto.
Conclusione AutoML
Vorrei ringraziarti per aver dedicato del tempo alla lettura di questo articolo su AutoML e librerie Python per il machine learning automatizzato. Spero che tu abbia trovato queste informazioni utili e interessanti per la tua attività di sviluppo. Il campo del machine learning sta crescendo rapidamente, e l'automazione sta diventando sempre più importante per migliorare l'efficienza e la produttività.
Con AutoML e le librerie Python descritte in questo articolo, puoi velocizzare il processo di creazione di modelli di machine learning e ottenere risultati migliori in meno tempo.
Se hai domande o commenti su questo argomento, ti invito a condividerli nella sezione dei commenti qui sotto. Grazie ancora per aver letto questo articolo e ti auguro buona fortuna nel tuo prossimo progetto di machine learning!
.png)
