tpot
v0.12.2
Estado maestro:
Estado de desarrollo:
Información del paquete:
Para probar el TPOT2 ( alfa ), vaya aquí.
TPOT significa herramienta de optimización de tuberías basada en árboles . Considere a TPOT como su asistente de ciencia de datos . TPOT es una herramienta de aprendizaje automático automatizado de Python que optimiza los procesos de aprendizaje automático mediante programación genética.
TPOT automatizará la parte más tediosa del aprendizaje automático explorando inteligentemente miles de posibles canalizaciones para encontrar la mejor para sus datos.
Un ejemplo de proceso de aprendizaje automático
Una vez que TPOT termina de buscar (o se cansa de esperar), le proporciona el código Python para la mejor canalización que encontró para que pueda modificar la canalización desde allí.
TPOT está construido sobre scikit-learn, por lo que todo el código que genera debería resultarle familiar... si está familiarizado con scikit-learn, de todos modos.
TPOT aún se encuentra en desarrollo activo y le recomendamos que consulte este repositorio con regularidad para obtener actualizaciones.
Para obtener más información sobre TPOT, consulte la documentación del proyecto.
Consulte la licencia del repositorio para obtener información sobre licencias y uso de TPOT.
Generalmente, tenemos licencia de TPOT para que sea lo más utilizable posible.
Mantenemos las instrucciones de instalación de TPOT en la documentación. TPOT requiere una instalación funcional de Python.
TPOT se puede utilizar en la línea de comandos o con código Python.
Haga clic en los enlaces correspondientes para encontrar más información sobre el uso de TPOT en la documentación.
A continuación se muestra un ejemplo de trabajo mínimo con el reconocimiento óptico de un conjunto de datos de dígitos escritos a mano.
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' ) La ejecución de este código debería descubrir una canalización que logra aproximadamente un 98 % de precisión en las pruebas, y el código Python correspondiente debería exportarse al archivo tpot_digits_pipeline.py y tener un aspecto similar al siguiente:
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 )De manera similar, TPOT puede optimizar las canalizaciones para problemas de regresión. A continuación se muestra un ejemplo de trabajo mínimo con el conjunto de datos prácticos de precios de vivienda de Boston.
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' ) lo que debería dar como resultado una canalización que alcance aproximadamente un error cuadrático medio (MSE) de 12,77, y el código de Python en tpot_boston_pipeline.py debería ser similar a:
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 )Consulte la documentación para obtener más ejemplos y tutoriales.
Le invitamos a comprobar los problemas existentes en busca de errores o mejoras en las que trabajar. Si tiene una idea para una extensión de TPOT, presente un nuevo número para que podamos discutirlo.
Antes de enviar cualquier contribución, revise nuestras pautas de contribución.
Verifique los problemas abiertos y cerrados existentes para ver si su problema ya ha sido atendido. Si no es así, presente un nuevo problema en este repositorio para que podamos revisarlo.
Si utiliza TPOT en una publicación científica, considere citar al menos uno de los siguientes artículos:
Trang T. Le, Weixuan Fu y Jason H. Moore (2020). Escalar el aprendizaje automático automatizado basado en árboles a big data biomédicos con un selector de conjunto de funciones. Bioinformática .36(1): 250-256.
Entrada BibTeX:
@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 y Jason H. Moore (2016). Automatización de la ciencia de datos biomédicos mediante la optimización de canalizaciones basadas en árboles. Aplicaciones de la Computación Evolutiva , páginas 123-137.
Entrada BibTeX:
@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 y Jason H. Moore (2016). Evaluación de una herramienta de optimización de canalizaciones basada en árboles para automatizar la ciencia de datos. Actas de GECCO 2016 , páginas 485-492.
Entrada BibTeX:
@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 } ,
}Alternativamente, puedes citar el repositorio directamente con el siguiente DOI:
TPOT se desarrolló en el Laboratorio de Genética Computacional de la Universidad de Pensilvania con financiación del NIH en el marco de la subvención R01 AI117694. Estamos increíblemente agradecidos por el apoyo de los NIH y la Universidad de Pensilvania durante el desarrollo de este proyecto.
El logotipo de TPOT fue diseñado por Todd Newmuis, quien generosamente donó su tiempo al proyecto.
