tpot
v0.12.2
Masterstatus:
Entwicklungsstand:
Paketinformationen:
Um den TPOT2 ( Alpha ) auszuprobieren, klicken Sie bitte hier!
TPOT steht für T ree-based Pipeline O ptimization Tool . Betrachten Sie TPOT als Ihren Data Science-Assistenten . TPOT ist ein Python-Tool für automatisiertes maschinelles Lernen, das Pipelines für maschinelles Lernen mithilfe genetischer Programmierung optimiert.
TPOT automatisiert den mühsamsten Teil des maschinellen Lernens, indem es Tausende möglicher Pipelines intelligent durchsucht, um die beste für Ihre Daten zu finden.
Eine beispielhafte Pipeline für maschinelles Lernen
Sobald TPOT mit der Suche fertig ist (oder Sie das Warten satt haben), stellt es Ihnen den Python-Code für die beste gefundene Pipeline zur Verfügung, sodass Sie von dort aus an der Pipeline herumbasteln können.
TPOT baut auf scikit-learn auf, daher sollte der gesamte Code, den es generiert, Ihnen bekannt vorkommen – jedenfalls wenn Sie mit scikit-learn vertraut sind.
TPOT befindet sich noch in der aktiven Entwicklung und wir empfehlen Ihnen, regelmäßig in diesem Repository nach Updates zu suchen.
Weitere Informationen zu TPOT finden Sie in der Projektdokumentation.
Die Lizenzierungs- und Nutzungsinformationen für TPOT finden Sie in der Repository-Lizenz.
Generell haben wir TPOT lizenziert, um es möglichst umfassend nutzbar zu machen.
Wir pflegen die TPOT-Installationsanweisungen in der Dokumentation. TPOT erfordert eine funktionierende Installation von Python.
TPOT kann in der Befehlszeile oder mit Python-Code verwendet werden.
Klicken Sie auf die entsprechenden Links, um weitere Informationen zur TPOT-Nutzung in der Dokumentation zu finden.
Nachfolgend finden Sie ein minimales Arbeitsbeispiel mit dem Datensatz zur optischen Erkennung handschriftlicher Ziffern.
from tpot import TPOTClassifier
from sklearn . datasets import load_digits
from sklearn . model_selection import train_test_split
digits = load_digits ()
X_train , X_test , y_train , y_test = train_test_split ( digits . data , digits . target ,
train_size = 0.75 , test_size = 0.25 , random_state = 42 )
tpot = TPOTClassifier ( generations = 5 , population_size = 50 , verbosity = 2 , random_state = 42 )
tpot . fit ( X_train , y_train )
print ( tpot . score ( X_test , y_test ))
tpot . export ( 'tpot_digits_pipeline.py' ) Beim Ausführen dieses Codes sollte eine Pipeline entdeckt werden, die eine Testgenauigkeit von etwa 98 % erreicht, und der entsprechende Python-Code sollte in die Datei tpot_digits_pipeline.py exportiert werden und etwa wie folgt aussehen:
import numpy as np
import pandas as pd
from sklearn . ensemble import RandomForestClassifier
from sklearn . linear_model import LogisticRegression
from sklearn . model_selection import train_test_split
from sklearn . pipeline import make_pipeline , make_union
from sklearn . preprocessing import PolynomialFeatures
from tpot . builtins import StackingEstimator
from tpot . export_utils import set_param_recursive
# 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 = 42 )
# Average CV score on the training set was: 0.9799428471757372
exported_pipeline = make_pipeline (
PolynomialFeatures ( degree = 2 , include_bias = False , interaction_only = False ),
StackingEstimator ( estimator = LogisticRegression ( C = 0.1 , dual = False , penalty = "l1" )),
RandomForestClassifier ( bootstrap = True , criterion = "entropy" , max_features = 0.35000000000000003 , min_samples_leaf = 20 , min_samples_split = 19 , n_estimators = 100 )
)
# Fix random state for all the steps in exported pipeline
set_param_recursive ( exported_pipeline . steps , 'random_state' , 42 )
exported_pipeline . fit ( training_features , training_target )
results = exported_pipeline . predict ( testing_features )Ebenso kann TPOT Pipelines für Regressionsprobleme optimieren. Nachfolgend finden Sie ein minimales Arbeitsbeispiel mit dem Übungsdatensatz „Bostoner Immobilienpreise“.
from tpot import TPOTRegressor
from sklearn . datasets import load_boston
from sklearn . model_selection import train_test_split
housing = load_boston ()
X_train , X_test , y_train , y_test = train_test_split ( housing . data , housing . target ,
train_size = 0.75 , test_size = 0.25 , random_state = 42 )
tpot = TPOTRegressor ( generations = 5 , population_size = 50 , verbosity = 2 , random_state = 42 )
tpot . fit ( X_train , y_train )
print ( tpot . score ( X_test , y_test ))
tpot . export ( 'tpot_boston_pipeline.py' ) Dies sollte zu einer Pipeline führen, die einen mittleren quadratischen Fehler (MSE) von etwa 12,77 erreicht, und der Python-Code in tpot_boston_pipeline.py sollte etwa so aussehen:
import numpy as np
import pandas as pd
from sklearn . ensemble import ExtraTreesRegressor
from sklearn . model_selection import train_test_split
from sklearn . pipeline import make_pipeline
from sklearn . preprocessing import PolynomialFeatures
from tpot . export_utils import set_param_recursive
# 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 = 42 )
# Average CV score on the training set was: -10.812040755234403
exported_pipeline = make_pipeline (
PolynomialFeatures ( degree = 2 , include_bias = False , interaction_only = False ),
ExtraTreesRegressor ( bootstrap = False , max_features = 0.5 , min_samples_leaf = 2 , min_samples_split = 3 , n_estimators = 100 )
)
# Fix random state for all the steps in exported pipeline
set_param_recursive ( exported_pipeline . steps , 'random_state' , 42 )
exported_pipeline . fit ( training_features , training_target )
results = exported_pipeline . predict ( testing_features )Weitere Beispiele und Tutorials finden Sie in der Dokumentation.
Wir heißen Sie herzlich willkommen, die bestehenden Probleme auf Fehler oder Verbesserungen zu prüfen, an denen gearbeitet werden muss. Wenn Sie eine Idee für eine Erweiterung des TPOT haben, reichen Sie bitte ein neues Problem ein, damit wir es besprechen können.
Bevor Sie Beiträge einreichen, lesen Sie bitte unsere Beitragsrichtlinien.
Bitte überprüfen Sie die vorhandenen offenen und geschlossenen Probleme, um festzustellen, ob Ihr Problem bereits bearbeitet wurde. Ist dies nicht der Fall, reichen Sie ein neues Problem in diesem Repository ein, damit wir Ihr Problem überprüfen können.
Wenn Sie TPOT in einer wissenschaftlichen Veröffentlichung verwenden, denken Sie bitte darüber nach, mindestens einen der folgenden Artikel zu zitieren:
Trang T. Le, Weixuan Fu und Jason H. Moore (2020). Skalierung des baumbasierten automatisierten maschinellen Lernens auf biomedizinische Big Data mit einem Feature-Set-Selektor. Bioinformatik .36(1): 250-256.
BibTeX-Eintrag:
@article { le2020scaling ,
title = { Scaling tree-based automated machine learning to biomedical big data with a feature set selector } ,
author = { Le, Trang T and Fu, Weixuan and Moore, Jason H } ,
journal = { Bioinformatics } ,
volume = { 36 } ,
number = { 1 } ,
pages = { 250--256 } ,
year = { 2020 } ,
publisher = { Oxford University Press }
}Randal S. Olson, Ryan J. Urbanowicz, Peter C. Andrews, Nicole A. Lavender, La Creis Kidd und Jason H. Moore (2016). Automatisierung der biomedizinischen Datenwissenschaft durch baumbasierte Pipeline-Optimierung. Anwendungen der Evolutionsberechnung , Seiten 123–137.
BibTeX-Eintrag:
@inbook { Olson2016EvoBio ,
author = { Olson, Randal S. and Urbanowicz, Ryan J. and Andrews, Peter C. and Lavender, Nicole A. and Kidd, La Creis and Moore, Jason H. } ,
editor = { Squillero, Giovanni and Burelli, Paolo } ,
chapter = { Automating Biomedical Data Science Through Tree-Based Pipeline Optimization } ,
title = { Applications of Evolutionary Computation: 19th European Conference, EvoApplications 2016, Porto, Portugal, March 30 -- April 1, 2016, Proceedings, Part I } ,
year = { 2016 } ,
publisher = { Springer International Publishing } ,
pages = { 123--137 } ,
isbn = { 978-3-319-31204-0 } ,
doi = { 10.1007/978-3-319-31204-0_9 } ,
url = { http://dx.doi.org/10.1007/978-3-319-31204-0_9 }
}Randal S. Olson, Nathan Bartley, Ryan J. Urbanowicz und Jason H. Moore (2016). Evaluierung eines baumbasierten Pipeline-Optimierungstools zur Automatisierung der Datenwissenschaft. Proceedings of GECCO 2016 , Seiten 485–492.
BibTeX-Eintrag:
@inproceedings { OlsonGECCO2016 ,
author = { Olson, Randal S. and Bartley, Nathan and Urbanowicz, Ryan J. and Moore, Jason H. } ,
title = { Evaluation of a Tree-based Pipeline Optimization Tool for Automating Data Science } ,
booktitle = { Proceedings of the Genetic and Evolutionary Computation Conference 2016 } ,
series = { GECCO '16 } ,
year = { 2016 } ,
isbn = { 978-1-4503-4206-3 } ,
location = { Denver, Colorado, USA } ,
pages = { 485--492 } ,
numpages = { 8 } ,
url = { http://doi.acm.org/10.1145/2908812.2908918 } ,
doi = { 10.1145/2908812.2908918 } ,
acmid = { 2908918 } ,
publisher = { ACM } ,
address = { New York, NY, USA } ,
}Alternativ können Sie das Repositorium auch direkt mit folgendem DOI zitieren:
TPOT wurde im Computational Genetics Lab der University of Pennsylvania mit Mitteln des NIH im Rahmen des Zuschusses R01 AI117694 entwickelt. Wir sind dem NIH und der University of Pennsylvania für die Unterstützung bei der Entwicklung dieses Projekts unglaublich dankbar.
Das TPOT-Logo wurde von Todd Newmuis entworfen, der großzügig seine Zeit für das Projekt gespendet hat.
