tsai
v0.3.9
Biblioteca de Deep Learning de última geração para séries temporais e sequências.
tsai é um pacote de aprendizado profundo de código aberto desenvolvido com base em Pytorch e fastai, focado em técnicas de última geração para tarefas de séries temporais como classificação, regressão, previsão, imputação…
tsai está atualmente em desenvolvimento ativo pela timeseriesAI.
Durante os últimos lançamentos, aqui estão algumas das adições mais significativas ao tsai :
tsai :Você pode instalar a versão estável mais recente do pip usando:
pip install tsaiSe você planeja desenvolver o tsai sozinho ou deseja estar na vanguarda, pode usar uma instalação editável. Primeiro instale o PyTorch e depois:
git clone https : // github . com / timeseriesAI / tsai
pip install - e "tsai[dev]"Nota: a partir do tsai 0.3.0, o tsai instalará apenas dependências rígidas. Outras dependências flexíveis (que são necessárias apenas para tarefas selecionadas) não serão instaladas por padrão (esta é a abordagem recomendada. Se você precisar de alguma das dependências que não esteja instalada, tsai solicitará que você a instale quando necessário). Se você ainda deseja instalar o tsai com todas as suas dependências, você pode fazer isso executando:
pip install tsai [ extras ]Você também pode instalar o tsai usando o conda (observe que se você substituir o conda pelo mamba, o processo de instalação será muito mais rápido e confiável):
conda install - c timeseriesai tsai Aqui está o link para a documentação.
Aqui está uma lista com alguns dos modelos de última geração disponíveis em tsai :
além de outros modelos personalizados como: TransformerModel, LSTMAttention, GRUAttention,…
Para conhecer o pacote tsai, sugerimos que você comece com este notebook no Google Colab: 01_Intro_to_Time_Series_Classification Ele fornece uma visão geral de uma tarefa de classificação de série temporal.
Também desenvolvemos muitos outros cadernos tutoriais.
Para usar tsai em seus próprios notebooks, a única coisa que você precisa fazer depois de instalar o pacote é executar isto:
from tsai . all import * Estes são apenas alguns exemplos de como você pode usar tsai :
Treinamento:
from tsai . basics import *
X , y , splits = get_classification_data ( 'ECG200' , split_data = False )
tfms = [ None , TSClassification ()]
batch_tfms = TSStandardize ()
clf = TSClassifier ( X , y , splits = splits , path = 'models' , arch = "InceptionTimePlus" , tfms = tfms , batch_tfms = batch_tfms , metrics = accuracy , cbs = ShowGraph ())
clf . fit_one_cycle ( 100 , 3e-4 )
clf . export ( "clf.pkl" ) Inferência:
from tsai . inference import load_learner
clf = load_learner ( "models/clf.pkl" )
probas , target , preds = clf . get_X_preds ( X [ splits [ 1 ]], y [ splits [ 1 ]])Treinamento:
from tsai . basics import *
X , y , splits = get_classification_data ( 'LSST' , split_data = False )
tfms = [ None , TSClassification ()]
batch_tfms = TSStandardize ( by_sample = True )
mv_clf = TSClassifier ( X , y , splits = splits , path = 'models' , arch = "InceptionTimePlus" , tfms = tfms , batch_tfms = batch_tfms , metrics = accuracy , cbs = ShowGraph ())
mv_clf . fit_one_cycle ( 10 , 1e-2 )
mv_clf . export ( "mv_clf.pkl" )Inferência:
from tsai . inference import load_learner
mv_clf = load_learner ( "models/mv_clf.pkl" )
probas , target , preds = mv_clf . get_X_preds ( X [ splits [ 1 ]], y [ splits [ 1 ]])Treinamento:
from tsai . basics import *
X , y , splits = get_regression_data ( 'AppliancesEnergy' , split_data = False )
tfms = [ None , TSRegression ()]
batch_tfms = TSStandardize ( by_sample = True )
reg = TSRegressor ( X , y , splits = splits , path = 'models' , arch = "TSTPlus" , tfms = tfms , batch_tfms = batch_tfms , metrics = rmse , cbs = ShowGraph (), verbose = True )
reg . fit_one_cycle ( 100 , 3e-4 )
reg . export ( "reg.pkl" )Inferência:
from tsai . inference import load_learner
reg = load_learner ( "models/reg.pkl" )
raw_preds , target , preds = reg . get_X_preds ( X [ splits [ 1 ]], y [ splits [ 1 ]])Os ROCKETs (RocketClassifier, RocketRegressor, MiniRocketClassifier, MiniRocketRegressor, MiniRocketVotingClassifier ou MiniRocketVotingRegressor) são modelos um tanto diferentes. Na verdade, eles não são modelos de aprendizado profundo (embora usem convoluções) e são usados de uma maneira diferente.
pip install sktimeou use:
pip install tsai [ extras ]Treinamento:
from sklearn . metrics import mean_squared_error , make_scorer
from tsai . data . external import get_Monash_regression_data
from tsai . models . MINIROCKET import MiniRocketRegressor
X_train , y_train , * _ = get_Monash_regression_data ( 'AppliancesEnergy' )
rmse_scorer = make_scorer ( mean_squared_error , greater_is_better = False )
reg = MiniRocketRegressor ( scoring = rmse_scorer )
reg . fit ( X_train , y_train )
reg . save ( 'MiniRocketRegressor' )Inferência:
from sklearn . metrics import mean_squared_error
from tsai . data . external import get_Monash_regression_data
from tsai . models . MINIROCKET import load_minirocket
* _ , X_test , y_test = get_Monash_regression_data ( 'AppliancesEnergy' )
reg = load_minirocket ( 'MiniRocketRegressor' )
y_pred = reg . predict ( X_test )
mean_squared_error ( y_test , y_pred , squared = False )Você pode usar tsai para previsão nos seguintes cenários:
Você precisará: * preparar X (entrada de série temporal) e o alvo y (ver documentação) * selecionar PatchTST ou um dos modelos do tsai terminando em Plus (TSTPlus, InceptionTimePlus, TSiTPlus, etc). O modelo configurará automaticamente um cabeçote para produzir uma saída com o mesmo formato da entrada alvo y.
Treinamento:
from tsai . basics import *
ts = get_forecasting_time_series ( "Sunspots" ). values
X , y = SlidingWindow ( 60 , horizon = 1 )( ts )
splits = TimeSplitter ( 235 )( y )
tfms = [ None , TSForecasting ()]
batch_tfms = TSStandardize ()
fcst = TSForecaster ( X , y , splits = splits , path = 'models' , tfms = tfms , batch_tfms = batch_tfms , bs = 512 , arch = "TSTPlus" , metrics = mae , cbs = ShowGraph ())
fcst . fit_one_cycle ( 50 , 1e-3 )
fcst . export ( "fcst.pkl" )Inferência:
from tsai . inference import load_learner
fcst = load_learner ( "models/fcst.pkl" , cpu = False )
raw_preds , target , preds = fcst . get_X_preds ( X [ splits [ 1 ]], y [ splits [ 1 ]])
raw_preds . shape
# torch.Size([235, 1]) Este exemplo mostra como construir uma previsão univariada de 3 passos à frente.
Treinamento:
from tsai . basics import *
ts = get_forecasting_time_series ( "Sunspots" ). values
X , y = SlidingWindow ( 60 , horizon = 3 )( ts )
splits = TimeSplitter ( 235 , fcst_horizon = 3 )( y )
tfms = [ None , TSForecasting ()]
batch_tfms = TSStandardize ()
fcst = TSForecaster ( X , y , splits = splits , path = 'models' , tfms = tfms , batch_tfms = batch_tfms , bs = 512 , arch = "TSTPlus" , metrics = mae , cbs = ShowGraph ())
fcst . fit_one_cycle ( 50 , 1e-3 )
fcst . export ( "fcst.pkl" )Inferência:
from tsai . inference import load_learner
fcst = load_learner ( "models/fcst.pkl" , cpu = False )
raw_preds , target , preds = fcst . get_X_preds ( X [ splits [ 1 ]], y [ splits [ 1 ]])
raw_preds . shape
# torch.Size([235, 3]) O formato de entrada para todos os modelos de série temporal e modelos de imagem em tsai é o mesmo. Um np.ndarray (ou objeto semelhante a um array como zarr, etc) com 3 dimensões:
[# amostras x # variáveis x comprimento da sequência]
O formato de entrada para modelos tabulares em tsai (como TabModel, TabTransformer e TabFusionTransformer) é um dataframe do pandas. Veja exemplo.
Aceitamos contribuições de todos os tipos. Desenvolvimento de melhorias, correções de bugs, documentações, cadernos de tutoriais, …
Criamos um guia para ajudá-lo a começar a contribuir para o tsai. Você pode ler aqui.
Quer aproveitar ao máximo o timeseriesAI/tsai em um ambiente profissional? Deixe-nos ajudar. Envie-nos um e-mail para saber mais: [email protected]
Se você usar tsai em sua pesquisa, use a seguinte entrada do BibTeX:
@Misc{tsai,
author = {Ignacio Oguiza},
title = {tsai - A state-of-the-art deep learning library for time series and sequential data},
howpublished = {Github},
year = {2023},
url = {https://github.com/timeseriesAI/tsai}
}
