ktrain
v0.41.4
uma "faca do exército suíço" para aprendizado de máquina
ktrain.text.qa.generative_qa . Nosso pacote Onprem.llm deve ser usado para tarefas generativas de resposta a perguntas. Veja o Exemplo Notebook.O KTrain é um invólucro leve para o Deep Learning Library Tensorflow Keras (e outras bibliotecas) para ajudar a construir, treinar e implantar redes neurais e outros modelos de aprendizado de máquina. Inspirado nas extensões da estrutura da ML como Fastai e Ludwig , o KTrain foi projetado para tornar o aprendizado profundo e a IA mais acessível e mais fácil de se inscrever para recém -chegados e profissionais experientes. Com apenas algumas linhas de código, o KTrain permite que você faça de maneira fácil e rápida:
Empregue modelos rápidos, precisos e fáceis de usar para text , vision , graph e dados tabular :
text :vision :graph :tabular :Estime uma taxa de aprendizado ideal para o seu modelo, considerando seus dados usando um localizador de taxa de aprendizado
Utilize cronogramas das taxas de aprendizado, como a política triangular, a política de 1Cycle e o SGDR para minimizar efetivamente a perda e melhorar a generalização
Construa classificadores de texto para qualquer idioma (por exemplo, análise de sentimentos em árabe com Bert, análise de sentimentos chineses com NBSVM)
Treine facilmente modelos NER para qualquer idioma (por exemplo, holandês nerd)
Carregar e pré -processar dados de texto e imagem de uma variedade de formatos
Inspecione os pontos de dados que foram classificados incorretamente e fornecem explicações para ajudar a melhorar seu modelo
Aproveite uma API de previsão simples para salvar e implantar modelos e etapas de preprocessamento de dados para fazer previsões em novos dados brutos
Suporte interno para exportar modelos para ONNX e Tensorflow Lite (consulte o Exemplo de notebook para obter mais informações)
Consulte os seguintes cadernos do tutorial para obter um guia sobre como usar o KTrain em seus projetos:
Alguns tutoriais do blog e outros guias sobre o KTrain são mostrados abaixo:
KTrain: Um invólucro leve para as Keras para ajudar a treinar redes neurais
Classificação de texto Bert em 3 linhas de código
Classificação de texto com transformadores de rosto abraçados no Tensorflow 2 (sem lágrimas)
Construa um sistema de atendimento de perguntas de domínio aberto com Bert em 3 linhas de código
Finetuning Bert usando a classificação KTrain para desastres de Tweets de Hamiz Ahmed
Exemplos da PNL indonésia com Ktrain por Sandy Khosasi
Usando KTrain no Google Colab ? Veja estes exemplos de colab:
transformerTarefas como classificação de texto e classificação de imagem podem ser realizadas facilmente com apenas algumas linhas de código.
import ktrain
from ktrain import text as txt
# load data
( x_train , y_train ), ( x_test , y_test ), preproc = txt . texts_from_folder ( 'data/aclImdb' , maxlen = 500 ,
preprocess_mode = 'bert' ,
train_test_names = [ 'train' , 'test' ],
classes = [ 'pos' , 'neg' ])
# load model
model = txt . text_classifier ( 'bert' , ( x_train , y_train ), preproc = preproc )
# wrap model and data in ktrain.Learner object
learner = ktrain . get_learner ( model ,
train_data = ( x_train , y_train ),
val_data = ( x_test , y_test ),
batch_size = 6 )
# find good learning rate
learner . lr_find () # briefly simulate training to find good learning rate
learner . lr_plot () # visually identify best learning rate
# train using 1cycle learning rate schedule for 3 epochs
learner . fit_onecycle ( 2e-5 , 3 ) import ktrain
from ktrain import vision as vis
# load data
( train_data , val_data , preproc ) = vis . images_from_folder (
datadir = 'data/dogscats' ,
data_aug = vis . get_data_aug ( horizontal_flip = True ),
train_test_names = [ 'train' , 'valid' ],
target_size = ( 224 , 224 ), color_mode = 'rgb' )
# load model
model = vis . image_classifier ( 'pretrained_resnet50' , train_data , val_data , freeze_layers = 80 )
# wrap model and data in ktrain.Learner object
learner = ktrain . get_learner ( model = model , train_data = train_data , val_data = val_data ,
workers = 8 , use_multiprocessing = False , batch_size = 64 )
# find good learning rate
learner . lr_find () # briefly simulate training to find good learning rate
learner . lr_plot () # visually identify best learning rate
# train using triangular policy with ModelCheckpoint and implicit ReduceLROnPlateau and EarlyStopping
learner . autofit ( 1e-4 , checkpoint_folder = '/tmp/saved_weights' ) import ktrain
from ktrain import text as txt
# load data
( trn , val , preproc ) = txt . entities_from_txt ( 'data/ner_dataset.csv' ,
sentence_column = 'Sentence #' ,
word_column = 'Word' ,
tag_column = 'Tag' ,
data_format = 'gmb' ,
use_char = True ) # enable character embeddings
# load model
model = txt . sequence_tagger ( 'bilstm-crf' , preproc )
# wrap model and data in ktrain.Learner object
learner = ktrain . get_learner ( model , train_data = trn , val_data = val )
# conventional training for 1 epoch using a learning rate of 0.001 (Keras default for Adam optmizer)
learner . fit ( 1e-3 , 1 ) import ktrain
from ktrain import graph as gr
# load data with supervision ratio of 10%
( trn , val , preproc ) = gr . graph_nodes_from_csv (
'cora.content' , # node attributes/labels
'cora.cites' , # edge list
sample_size = 20 ,
holdout_pct = None ,
holdout_for_inductive = False ,
train_pct = 0.1 , sep = ' t ' )
# load model
model = gr . graph_node_classifier ( 'graphsage' , trn )
# wrap model and data in ktrain.Learner object
learner = ktrain . get_learner ( model , train_data = trn , val_data = val , batch_size = 64 )
# find good learning rate
learner . lr_find ( max_epochs = 100 ) # briefly simulate training to find good learning rate
learner . lr_plot () # visually identify best learning rate
# train using triangular policy with ModelCheckpoint and implicit ReduceLROnPlateau and EarlyStopping
learner . autofit ( 0.01 , checkpoint_folder = '/tmp/saved_weights' ) # load text data
categories = [ 'alt.atheism' , 'soc.religion.christian' , 'comp.graphics' , 'sci.med' ]
from sklearn . datasets import fetch_20newsgroups
train_b = fetch_20newsgroups ( subset = 'train' , categories = categories , shuffle = True )
test_b = fetch_20newsgroups ( subset = 'test' , categories = categories , shuffle = True )
( x_train , y_train ) = ( train_b . data , train_b . target )
( x_test , y_test ) = ( test_b . data , test_b . target )
# build, train, and validate model (Transformer is wrapper around transformers library)
import ktrain
from ktrain import text
MODEL_NAME = 'distilbert-base-uncased'
t = text . Transformer ( MODEL_NAME , maxlen = 500 , class_names = train_b . target_names )
trn = t . preprocess_train ( x_train , y_train )
val = t . preprocess_test ( x_test , y_test )
model = t . get_classifier ()
learner = ktrain . get_learner ( model , train_data = trn , val_data = val , batch_size = 6 )
learner . fit_onecycle ( 5e-5 , 4 )
learner . validate ( class_names = t . get_classes ()) # class_names must be string values
# Output from learner.validate()
# precision recall f1-score support
#
# alt.atheism 0.92 0.93 0.93 319
# comp.graphics 0.97 0.97 0.97 389
# sci.med 0.97 0.95 0.96 396
#soc.religion.christian 0.96 0.96 0.96 398
#
# accuracy 0.96 1502
# macro avg 0.95 0.96 0.95 1502
# weighted avg 0.96 0.96 0.96 1502 import ktrain
from ktrain import tabular
import pandas as pd
train_df = pd . read_csv ( 'train.csv' , index_col = 0 )
train_df = train_df . drop ([ 'Name' , 'Ticket' , 'Cabin' ], 1 )
trn , val , preproc = tabular . tabular_from_df ( train_df , label_columns = [ 'Survived' ], random_state = 42 )
learner = ktrain . get_learner ( tabular . tabular_classifier ( 'mlp' , trn ), train_data = trn , val_data = val )
learner . lr_find ( show_plot = True , max_epochs = 5 ) # estimate learning rate
learner . fit_onecycle ( 5e-3 , 10 )
# evaluate held-out labeled test set
tst = preproc . preprocess_test ( pd . read_csv ( 'heldout.csv' , index_col = 0 ))
learner . evaluate ( tst , class_names = preproc . get_classes ()) Verifique se o PIP está atualizado com: pip install -U pip
Instale o TensorFlow 2 se ainda não estiver instalado (por exemplo, pip install tensorflow ).
Instale Ktrain : pip install ktrain
Se estiver usando tensorflow>=2.16 :
pip install tf_kerasTF_USE_LEGACY_KERAS como TRUE antes de importar KtrainO exposto acima deve ser tudo o que você precisa em sistemas Linux e ambientes de computação em nuvem, como Google Colab e AWS EC2. Se você estiver usando o KTrain em um computador Windows , poderá seguir estas instruções mais detalhadas que incluem algumas etapas extras.
tensorflow>=2.11 , você deve usar apenas otimizadores herdados como tf.keras.optimizers.legacy.Adam . O mais recente tf.keras.optimizers.Optimizer Base Class não é suportado no momento. Por exemplo, ao usar o tensorflow 2.11 e acima, use tf.keras.optimzers.legacy.Adam() em vez da string "adam" no model.compile . O KTrain faz isso automaticamente ao usar modelos prontos para uso (por exemplo, modelos da biblioteca transformers ).tf_keras e também definir a variável de ambiente TF_USE_LEGACY_KERAS=True antes de importar kTrain (por exemplo, adicione export TF_USE_LEGACY_KERAS=1 em .bashrc ou add os.environ['TF_USE_LEGACY_KERAS']="1" eli5 e stellargraph para apoiar o Tensorflow2.) # for graph module:
pip install https : // github . com / amaiya / stellargraph / archive / refs / heads / no_tf_dep_082 . zip
# for text.TextPredictor.explain and vision.ImagePredictor.explain:
pip install https : // github . com / amaiya / eli5 - tf / archive / refs / heads / master . zip
# for tabular.TabularPredictor.explain:
pip install shap
# for text.zsl (ZeroShotClassifier), text.summarization, text.translation, text.speech:
pip install torch
# for text.speech:
pip install librosa
# for tabular.causal_inference_model:
pip install causalnlp
# for text.summarization.core.LexRankSummarizer:
pip install sumy
# for text.kw.KeywordExtractor
pip install textblob
# for text.generative_ai
pip install onprem O KTrain propositadamente representa uma versão mais baixa dos Transformers para incluir suporte para versões mais antigas do Tensorflow. Se você precisar de uma versão mais recente do transformers , geralmente é seguro para você atualizar transformers , desde que o fizer depois de instalar o Ktrain .
A partir da v0.30.x, a instalação do TensorFlow é opcional e só é necessária se o treinamento de redes neurais. Embora o KTrain use o TensorFlow para o treinamento de rede neural, ele também inclui uma variedade de modelos de Pytorch pré-tenhados e modelos de Sklearn, que podem ser usados fora da caixa sem ter o tensorflow instalado, conforme resumido nesta tabela:
| Recurso | Tensorflow | Pytorch | Sklearn |
|---|---|---|---|
| Treinando qualquer rede neural (por exemplo, classificação de texto ou imagem) | ✅ | ||
| Perguntas de ponta a ponta-resposta (pré-terem sido pré-criadas) | ✅ | ✅ | |
| Extração de informações baseada em controle de qualidade (pré-teria) | ✅ | ✅ | |
| Classificação zero-tiro (pré-criada) | ✅ | ||
| Tradução de idiomas (pré -terenciosa) | ✅ | ||
| Resumo (pré -terenciado) | ✅ | ||
| Transcrição de fala (pré -terenciosa) | ✅ | ||
| Legenda da imagem (pré -teria) | ✅ | ||
| Detecção de objetos (pré -terenciada) | ✅ | ||
| Análise de sentimentos (pré -terenciado) | ✅ | ||
| Generativeai (transformadores de frases) | ✅ | ||
| Modelagem de tópicos (Sklearn) | ✅ | ||
| Extração da shalfrae (textblob/nltk/sklearn) | ✅ |
Conforme observado acima, a respostas de perguntas de ponta a ponta e a extração de informações no KTrain pode ser usada com o tensorflow (usando framework='tf' ) ou pytorch (usando framework='pt' ).
Cite o artigo a seguir ao usar o KTrain :
@article{maiya2020ktrain,
title={ktrain: A Low-Code Library for Augmented Machine Learning},
author={Arun S. Maiya},
year={2020},
eprint={2004.10703},
archivePrefix={arXiv},
primaryClass={cs.LG},
journal={arXiv preprint arXiv:2004.10703},
}
Criador: Arun S. Maiya
Email: Arun [at] Maiya [DOT] Net
