tpot
v0.12.2
Status mestre:
Estado de desenvolvimento:
Informações do pacote:
Para experimentar o TPOT2 ( alfa ), clique aqui!
TPOT significa Tree -based P ipeline O ptimization Tool . Considere o TPOT seu assistente de ciência de dados . TPOT é uma ferramenta Python Automated Machine Learning que otimiza pipelines de aprendizado de máquina usando programação genética.
O TPOT automatizará a parte mais tediosa do aprendizado de máquina, explorando de forma inteligente milhares de pipelines possíveis para encontrar o melhor para seus dados.
Um exemplo de pipeline de aprendizado de máquina
Assim que o TPOT terminar a pesquisa (ou você se cansar de esperar), ele fornecerá o código Python para o melhor pipeline encontrado para que você possa mexer no pipeline a partir daí.
O TPOT é construído com base no scikit-learn, portanto, todo o código que ele gera deve parecer familiar... se você estiver familiarizado com o scikit-learn, de qualquer maneira.
O TPOT ainda está em desenvolvimento ativo e encorajamos você a verificar este repositório regularmente para atualizações.
Para mais informações sobre o TPOT, consulte a documentação do projeto.
Consulte a licença do repositório para obter informações de licenciamento e uso do TPOT.
Geralmente, licenciamos o TPOT para torná-lo o mais amplamente utilizável possível.
Mantemos as instruções de instalação do TPOT na documentação. TPOT requer uma instalação funcional do Python.
TPOT pode ser usado na linha de comando ou com código Python.
Clique nos links correspondentes para encontrar mais informações sobre o uso do TPOT na documentação.
Abaixo está um exemplo prático mínimo com o reconhecimento óptico de um conjunto de dados de dígitos manuscritos.
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' ) A execução deste código deve descobrir um pipeline que atinge cerca de 98% de precisão de teste, e o código Python correspondente deve ser exportado para o arquivo tpot_digits_pipeline.py e ter uma aparência semelhante ao seguinte:
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 )Da mesma forma, o TPOT pode otimizar pipelines para problemas de regressão. Abaixo está um exemplo prático mínimo com o conjunto de dados práticos de preços de habitação 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' ) o que deve resultar em um pipeline que atinge cerca de 12,77 erro quadrático médio (MSE), e o código Python em tpot_boston_pipeline.py deve ser semelhante 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 )Verifique a documentação para mais exemplos e tutoriais.
Convidamos você a verificar os problemas existentes em busca de bugs ou melhorias para trabalhar. Se você tiver uma ideia para uma extensão do TPOT, registre um novo problema para que possamos discuti-lo.
Antes de enviar qualquer contribuição, revise nossas diretrizes de contribuição.
Verifique os problemas abertos e fechados existentes para ver se o seu problema já foi resolvido. Caso contrário, registre um novo problema neste repositório para que possamos revisar seu problema.
Se você usar TPOT em uma publicação científica, considere citar pelo menos um dos seguintes artigos:
Trang T. Le, Weixuan Fu e Jason H. Moore (2020). Dimensione o aprendizado de máquina automatizado baseado em árvore para big data biomédico com um seletor de conjunto de recursos. 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 e Jason H. Moore (2016). Automatizando a ciência de dados biomédicos por meio da otimização de pipeline baseada em árvore. Aplicações de Computação Evolucionária , 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 e Jason H. Moore (2016). Avaliação de uma ferramenta de otimização de pipeline baseada em árvore para automatizar a ciência de dados. Anais do 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, você pode citar o repositório diretamente com o seguinte DOI:
O TPOT foi desenvolvido no Laboratório de Genética Computacional da Universidade da Pensilvânia com financiamento do NIH sob a concessão R01 AI117694. Estamos extremamente gratos pelo apoio do NIH e da Universidade da Pensilvânia durante o desenvolvimento deste projeto.
O logotipo do TPOT foi desenhado por Todd Newmuis, que generosamente doou seu tempo para o projeto.
