NLP | Treinamento mais rápido de modelos de Deep Learning maiores com um GPU no Google Colab
Este post é a segunda parte da publicação de um conjunto de dicas sobre como treinar um modelo de Deep Learning no Google Colab (ou qualquer plataforma com GPU). O primeiro post não era específico para um determinado tipo de modelo, enquanto esse diz respeito a modelos de NLP cujo número de parâmetros (às vezes bilhões) apresenta problemas específicos para seu treinamento.
Link para o primeiro post:
Sumário
- Contexto
- Colab+ (Google)
1. Use o melhor GPU (P100) e a RAM de CPU máxima
2. Use a versão de CUDA mais recente
3. Economize espaço no disco Colab
4. Use a técnica do gradiente médio (accumulating gradient) para simular um batch maior
5. Use fp16 (Half-precision floating point format)
6. Use as bibliotecas de NLP mais recentes
7. Adicione métricas de desempenho do modelo
8. Procure o melhor Learning Rate para treinar o modelo
9. Mantenha apenas o modelo com o melhor desempenho
10. Use o Tensorboard para visualizaras curvas de treinamento (Learning Rate, perda de treinamento e validação, métricas, etc.)
- Gradient Checkpointing (Open AI)
- DeepSpeed (Microsoft)
Contexto
Publiquei anteriormente um post (Como treinar um modelo de Deep Learning no Google Colab?) sobre como treinar um modelo de Deep Learning no Google Colab (ou Colab), sem distinção entre arquiteturas de modelo (Convolution Network, Transformer, etc.) e a natureza dos dados (imagens, textos, etc.).
O conselho principal então foi como obter o melhor GPU possível no Colab (nesse caso, um GPU Tesla P100 de 16 GB) e o máximo de RAM de CPU para seu notebook (26 GB).
No entanto, quando se trata de treinar modelos de Deep Learning de NLP, é necessário usar técnicas adicionais no notebook do Colab. Na verdade, o tamanho dos modelos de NLP (e especialmente os modelos mais recentes devido ao seu número de parâmetros) rapidamente apresenta problemas de tamanho de RAM e tempo quando tem apenas um único GPU.
Felizmente, existem soluções!
Para ajudar todos aqueles que desejam treinar tais modelos de NLP no Colab (ou em qualquer outra plataforma com GPU), abaixo estão 3 parágrafos apresentando os problemas e suas soluções, bem como um notebook online no Colab que contém as soluções de código apresentado nesse post.
Notebook no Colab: template_to_run_a_Deep_Learning_notebook_with_a_NLP_model_in_Google_Colab.ipynb
Nota: para aqueles que desejam obter ainda mais informações atualizadas sobre as técnicas de fine-tuning de um grande modelo de NLP em um único GPU, aqui está a recente apresentação vídeo (25/02/2021) de Sylvain Gugger (Hugging Face) e seus slides. Essa apresentação é muito completa!
Colab+
Eu chamo Colab+, o uso otimizado do Colab para ser capaz de treinar um modelo de Deep Learning de NLP.
1. Use o melhor GPU (P100) e a RAM de CPU máxima
No post anterior (notebook), vimos como forçar a Colab a associar seu melhor GPU (Tesla P100 com 16 GB) ao nosso notebook de Deep Learning e dobrar a RAM de CPU disponível para 26 GB.
2. [EDIT: 26/02/2021] Use a versão de CUDA mais recente
Com o código seguinte, pode verificar a versão de CUDA associado ao GPU que usa o seu notebook no Colab:
!nvcc --versionnvcc: NVIDIA (R) Cuda compiler driver Copyright (c) 2005-2019 NVIDIA Corporation Built on Sun_Jul_28_19:07:16_PDT_2019 Cuda compilation tools, release 10.1, V10.1.243
Como a versão10.1 não é a mais recente — em 24/02/2021, é a versão 11.2.1 — (verifique este link para conhecer a versão mais recente de CUDA), pode atualizá-la com o código seguinte (cerca de 5mn para terminar):
# Uninstall the current CUDA version
!apt-get --purge remove cuda nvidia* libnvidia-*
!dpkg -l | grep cuda- | awk '{print $2}' | xargs -n1 dpkg --purge
!apt-get remove cuda-*
!apt autoremove
!apt-get update# Download CUDA
!wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin
!sudo mv cuda-ubuntu1804.pin /etc/apt/preferences.d/cuda-repository-pin-600
!wget https://developer.download.nvidia.com/compute/cuda/11.2.1/local_installers/cuda-repo-ubuntu1804-11-2-local_11.2.1-460.32.03-1_amd64.deb
!sudo dpkg -i cuda-repo-ubuntu1804-11-2-local_11.2.1-460.32.03-1_amd64.deb
!sudo apt-key add /var/cuda-repo-ubuntu1804-11-2-local/7fa2af80.pub
!sudo apt-get update
!sudo apt-get -y install cuda
Nota: instalei a versão de CUDA para Ubuntu 18.04 porque é a versão utilizada na minha sessão de Colab (se for diferente, pode escolher a versão para Ubuntu 20.04 ou Ubuntu 16.04):
import platform
platform.platform()Linux-4.19.112+-x86_64-with-Ubuntu-18.04-bionic
Verifique de novo a sua versão de CUDA:
!nvcc --versionnvcc: NVIDIA (R) Cuda compiler driver Copyright (c) 2005-2021 NVIDIA Corporation Built on Thu_Jan_28_19:32:09_PST_2021 Cuda compilation tools, release 11.2, V11.2.142 Build cuda_11.2.r11.2/compiler.29558016_0
Et voilà! (versão de CUDA = 11.2)
Nota: se uma das outras bibliotecas do seu notebook não funciona com CUDA 11, volte para CUDA 10.2 (Ambiente de execução >> Redefinir o ambiente de execução para a configuração original).
3. Economize espaço no disco Colab
No entanto, outro problema de memória, o do tamanho do disco Colab associado ao notebook desta vez, pode impedi-lo de treinar um modelo de NLP.
De fato, como o treinamento de um modelo de NLP costuma ser longo, a maioria das bibliotecas de NLP salva regularmente as versões do modelo nos chamados diretórios checkpoint no disco associado ao notebook. Assim, caso apareça algum problema, é possível retomar o treinamento de um checkpoint de sua escolha.
Como não é possível aumentar o tamanho desse disco Colab associado ao seu notebook (que ainda está em torno de 68 GB), deve se lembrar de desativar este comportamento de backup de checkpoint.
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face, basta adicionar o seguinte argumento aos argumentos do TrainingArguments: save_total_limit=1
Assim, apenas o último checkpoint do seu modelo será salvo no disco e não dezenas.
args = TrainingArguments(
...
save_total_limit=1,
...)4. [EDIT: 26/02/2021] Use a técnica do gradiente médio (accumulating gradient) para simular um batch maior
(fonte) Ao treinar grandes redes neurais, pode acontecer que o maior tamanho de batch que pode pagar seja um ou em baixo do que queria. Nesses casos, o treinamento pode se tornar muito ineficiente e até mesmo não convergir devido a gradientes muito ruidosos.
O gradiente médio (accumulating gradient) é uma técnica que permite aumentar o tamanho do batch efetivo de forma arbitral, apesar das restrições de memória do GPU.
A ideia principal é separar o cálculo dos gradientes da sua aplicação. Se fizer isso, poderá calcular gradientes em cada iteração e aplicar uma média deles com menos frequência.
Concretamente, se batch_size é o seu numero de batch e gradient_accumulation_steps o seu gradiente médio, o seu numero de batch efetivo é: batch_size x gradient_accumulation_steps
batch_size = 8
gradient_accumulation_steps = 2batch_size_efetivo = 8 x 2 = 16
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face, basta adicionar o seguinte argumento aos argumentos do TrainingArguments: gradient_accumulation_steps=x (x é o número que vai multiplicar o seu batch).
args = TrainingArguments(
...
save_total_limit=1,
gradient_accumulation_steps=x,
...)Nota: mais informações no parágrafo deste post “Large batches on one or several GPU(s)”.
5. Use fp16 (Half-precision floating point format)
(fonte) fp16 usa 16 bits, em comparação com 32 bits para precisão única (fp32). A redução da memória necessária no GPU permite o treinamento de modelos maiores ou com batches maiores. … Essa técnica é chamada de treinamento de precisão mista, pois usa representações de precisão simples e meia (single- and half-precision representations).
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face, basta adicionar o seguinte argumento aos argumentos do TrainingArguments: fp16=True
args = TrainingArguments(
...
save_total_limit=1,
gradient_accumulation_steps=x,
fp16=True,
...)6. Use as bibliotecas de NLP mais recentes
Para obter todas as melhorias mais recentes, instalamos as versões mais recentes das bibliotecas.
# Check pytorch version
!pip install torch==1.7.1+cu110 torchvision==0.8.2+cu110 torchaudio===0.7.2 -f https://download.pytorch.org/whl/torch_stable.html# Install tensorflow
!pip install tf-nightly# Install Hugging Face libraries (datasets & transformers)
!pip install datasets git+https://github.com/huggingface/transformers/
7. [EDIT: 03/03/2021] Adicione métricas de desempenho do modelo
No mínimo, durante o treinamento de um modelo, as bibliotecas do Deep Learning exibem sua perda do treinamento e da validação (training e validation loss) no final de cada época.
Acompanhar a evolução dessas perdas é importante porque sua diminuição tanto para o dataset de treinamento quanto principalmente para o dataset de validação nos permite verificar se o treinamento do modelo está indo bem.
Porém, quando colocarmos em produção o modelo treinado, o que nos interessará não será essas perdas, mas os valores de uma ou mais métricas como por exemplo a acurácia de um modelo de classificação de imagens ou textos.
Assim, se não exibirmos ao final de cada época ao treinar o modelo, as métricas que usaremos em produção, não será possível verificar se o modelo não está em overfitting, por exemplo (no caso de um modelo de classificação, isso significa que a acurácia da validação aumenta em vez de descer), ou seja, que se especializou em dados de treinamento.
Nota: esteja ciente de que mesmo com a diminuição da perda de validação, a acurácia da validação pode aumentar! Para obter mais informações sobre as diferenças entre perda (loss) e métrica, leia o parágrafo que começa com “What is a metric?” no capítulo 1 do fastbook da fastai.
A questão que surge então é como exibir os valores da(s) métrica(s) durante o treinamento de um modelo de NLP?
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face, basta definir uma função de calculo da(s) métrica(s) da validação ao final de cada época e adicionar o seguinte argumento aos argumentos do Trainer: compute_metrics=compute_metrics
# example of function de compute_metrics in the case of a BertForSequenceClassification model fine-tuning (YOu MUST ADAPT IT TO YOUR CASE)
# source: https://huggingface.co/transformers/training.html#trainerfrom sklearn.metrics import accuracy_score, precision_recall_fscore_support
def compute_metrics(pred):
labels = pred.label_ids
preds = pred.predictions.argmax(-1)
precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary')
acc = accuracy_score(labels, preds)
return {
'accuracy': acc,
'f1': f1,
'precision': precision,
'recall': recall
}trainer = Trainer(
...
compute_metrics=compute_metrics,
...)
8. [EDIT: 05/03/2021] Procure o melhor Learning Rate para treinar o modelo
(fonte) Grandes Learning Rate levam a uma convergência de modelo mais rápida do que pequenas Learning Rate. Além disso, grandes Learning Rate são cruciais em programações de Learning Rate, como CLR e 1Cycle, que são usadas para treinar efetivamente com grandes tamanhos de batch.
O problema é como descobrir os valores de Learning Rate mais altos que podem ser usados para treinar um modelo sem divergência?
DeepSpeed fornece o método LRRT para isso! (para treinamento de modelo em estruturas PyTorch)
Nota: leia o parágrafo abaixo sobre como usar o DeepSpeed para treinar mais rápido um modelo de NLP com centenas de milhões (até bilhões) de parâmetros.
Há um tutorial no site DeepSpeed.ai sobre este método. Aqui estão os pontos principais:
- No código do arquivo ds_config.json de configuração DeepSpeed, escolhe o scheduler LRRangeTest (veja o tutorial para entender melhor como escolher os valores de seus parâmetros).
- Nos argumentos no TrainingArguments, coloque aqueles que são necessários para arquivar os dados de treinamento, além de ter instalado o TensorBoard e ter definido a pasta de arquivamento (veja as instruções no paragrafo em baixo “Use o Tensorboard para visualizaras curvas de treinamento (learning rate, perda de treinamento e validação, métricas, etc.)”).
- Treine o seu modelo.
- Abra o TensorBoard de seu treinamento no notebook (veja como no mesmo parágrafo abaixo).
- Encontre o Learning Rate a partir do qual seu modelo diverge.
Agora, com esse Learning Rate máximo e antes de roder de novo o notebook do seu modelo, pode escolher o scheduler de treinamento do seu modelo (por exemplo, na Hugging Face aqui está a lista, e no DeepSpeed, pode ser lr_schedule, LRRangeTest, OneCycle, WarmupLR, WarmupDecayLR), colocar os argumentos correspondentes no TrainingArguments se usa Transformers da Hugging Face, ou o código correspondente no arquivo ds_config.json de configuração se usa DeepSpeed. Et voilà!
9. [EDIT: 05/03/2021] Mantenha apenas o modelo com o melhor desempenho
Quando um modelo é treinado em várias épocas, pode acontecer que o modelo esteja com overfitting na última (ou últimas) época(s) (ou seja, o modelo se especializou em dados de treinamento e, consequentemente, seu desempenho nos dados da validação começou a se deteriorar).
A melhor opção é então reiniciar o treinamento do modelo com uma taxa de aprendizado (learning rate) um pouco menor, por exemplo, para terminar sem overfitting.
Porém, existe também outra solução se você não puder / não quiser reiniciar o treinamento do modelo:
- avaliar no final de cada época de acordo com a perda (loss) ou a métrica escolhida (opção preferencial) o desempenho do modelo no dataset da validação,
- comparar esse desempenho com o melhor obtido anteriormente,
- e manter unicamente o modelo com o melhor desempenho.
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face, basta adicionar o seguintes argumentos aos argumentos do TrainingArguments: load_best_model_at_end=True, metric_for_best_model=”…" (escolha a métrica da sua função compute_metrics do parágrafo precedente)
args = TrainingArguments(
...
save_total_limit=1,
gradient_accumulation_steps=x,
fp16=True,
load_best_model_at_end=True,
metric_for_best_model="...",
...)10. [EDIT: 03/03/2021] Use o Tensorboard para visualizaras curvas de treinamento (Learning Rate, perda de treinamento e validação, métricas, etc.)
Ao visualizar curvas de treinamento (Learning Rate, perda de treinamento e validação, métricas, etc.) ajuda a entender melhor o treinamento do seu modelo e a verificar que não houve um problema.
(fonte) O TensorBoard é uma ferramenta do Tensorflow que permite fazer justamente isso: é uma ferramenta que permite a visualização de qualquer estatística de uma rede neural como, por exemplo, parâmetros de treinamento (perda, acurácia e pesos), imagens e até o grafo construído.
A questão que surge então é como exibir TensorBoard no seu notebook depois do treinamento de um modelo de NLP?
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face, basta :
- instalar TensorBoard no ambiente do seu notebook com pip install tensorboard (no Colab ou se Tensorflow já está instalado, não precisa fazer isso)
- definir o caminho para a pasta que vai arquivar os dados de treinamento (por exemplo, logging_dir=’./logs/’)
- tornar o registro efetivo desses dados com os seguintes argumentos no TrainingArguments: logging_dir=logging_dir, logging_steps=1
- lançar o TensorBoard com 2 linhas de códigos (veja em baixo).
logging_dir='./logs/'args = TrainingArguments(
...
save_total_limit=1,
gradient_accumulation_steps=x,
fp16=True,
logging_dir=logging_dir,
logging_steps=1,
...)%load_ext tensorboard
%tensorboard --logdir {logging_dir}
Nota: se estiver rodando o seu notebook em uma plataforma diferente da Colab, o caminho para o TensorBoard pode não estar na variável PATH do seu ambiente. Nesse caso, o código a ser digitado em seu notebook antes de iniciar o TensorBoard pode ser encontrado aqui. Além disso, precisa adicionar um argumento bind_all da forma seguinte:
%load_ext tensorboard
%tensorboard --logdir {logging_dir} --bind_allVerifique o nosso notebook no Colab para ver o código!
Gradient Checkpointing (Open AI)
Com a explosão no número de parâmetros de modelos de NLP para vários bilhões, as melhorias propostas no parágrafo precedente (Colab+) não são, entretanto, suficientes para permitir que o GPU do Colab (um P100 com 16 GB) armazene todos os valores desses parâmetros e seus números associados durante o treinamento, como gradientes.
Felizmente, existe uma solução!
O post “Explore Gradient-Checkpointing in PyTorch” explica bem isso. Abaixo está a tradução para o português dos principais elementos desse post:
Em abril de 2019, OpenAI publicou seu trabalho sobre o Sparse Transformer. Apesar da contribuição da atenção esparsa (sparse attention), o artigo menciona uma maneira prática de reduzir o uso de memória de um modelo transformer. Esse método é chamado de Gradient Checkpointing, que é apresentado pela primeira vez no artigo “Training Deep Nets with Sublinear Memory Cost”.
O método Gradient checkpointing afirma reduzir o custo de memória para raiz de n ao treinar uma rede de n camadas. Isso se encaixa no cenário de transformers. Porque os transformers geralmente contêm muitas camadas e a parte mais intensiva da memória dos transformers é o armazenamento das matrizes de atenção N × N de saída de todas as camadas intermediárias de atenção com multi-head attentions.
A seguir está o uso da memória de atenção de 64 camadas e 4 heads Transformer pelo método de Gradient Checkpointing:
Na tabela, podemos observar que o método de Gradient Checkpointing economizou mais de 10 vezes o uso de memória em modelos Transformer. Para pesquisadores comuns que possuem apenas GPUs padrão com memória de 12 GB, essa pode ser uma boa notícia. E, potencialmente, não precisamos de dispositivos computacionais caros como TPU ou Tesla V100 para treinar grandes redes neurais como BERT.
(…)
Aplicando o método de Gradient Checkpointing, podemos reduzir muito a memória GPU necessária para treinar um modelo Transformer ao custo de uma computação ligeiramente mais lenta (10% ~ 20%).
A questão que surge então é como implementar esse método mágico que diminui tanto o uso da memória de um GPU para um modelo Transformer (modelo mais comum que é usado no NLP)?
Muito simples!
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face, basta adicionar os seguintes argumentos aos argumentos do AutoModel(…).from_pretrained: gradient_checkpointing=gradient_checkpointing, use_cache=use_cache
# exemplo de uso do método Gradient Checkpointing na HF com um modelo BERT QA
from transformers import AutoModelForQuestionAnsweringmodel = AutoModelForQuestionAnswering.from_pretrained(
model_checkpoint,
gradient_checkpointing=True,
use_cache=False)
Verifique o nosso notebook no Colab para ver o código!
Nota: aqui está a lista dos modelos de NLP que aceitam o argumento gradient_checkpointing na biblioteca Transformers da Hugging Face.
DeepSpeed (Microsoft)
[EDIT: 03/03/2021] Este parágrafo sobre DeepSpeed foi editado após novos testes no Colab. O que foi descoberto é que DeepSpeed funciona muito bem no Colab (permite de diminuir até 40% o tempo de treinamento de um modelo de NLP!) sem o uso do método Gradient Checkpointing (porque DeepSpeed também otimiza o tamanho do modelo no GPU) e com o modo CPU Offload desabilitado. Na verdade, esse modo permite que a RAM de CPU seja usada para liberar mais espaço no GPU durante o treinamento de um modelo, mas no Colab esse método parece impedir que o DeepSpeed reduza efetivamente o tempo de treinamento do modelo (provavelmente, por causa de uma comunicação ruim entre GPU e CPU — leia este post: “It’s important to understand that DeepSpeed ZeRO-Offload requires an ample CPU RAM to be available”).
Acabamos de ver no parágrafo anterior (Gradient Checkpointing (Open AI)) que agora é possível treinar um modelo de NLP ainda mais recente (ou seja, com possivelmente bilhões de parâmetros) em um único GPU no Colab.
No entanto, como o post “Explore Gradient-Checkpointing in PyTorch” menciona, há um custo de 10–20% de tempo extra. Como o tempo vale ouro (em termos de custo de computação), precisamos solucionar esse problema.
Felizmente, existe uma solução! Use DeepSpeed sem o método de Gradient Checkpointing e com “cpu_offload”: False no arquivo de configuração ds_config.json
DeepSpeed ZeRO
Em fevereiro de 2020, a Microsoft apresentou sua biblioteca de otimização de treinamento de Deep Learning de código aberto DeepSpeed (paper: “ZeRO: Memory Optimizations Toward Training Trillion Parameter Models”) com tecnologia de otimização de memória ZeRO (Zero Redundancy Optimizer), que ajudou a construir o modelo Turing Natural Language Generation (T-NLG) de 17 bilhões de parâmetros.
Aqui está uma apresentação do DeepSpeed ZeRO da Microsoft (post: “Models, Infrastructure and Hardware for Next-Generation AI Applications”):
DeepSpeed is a PyTorch-compatible library that vastly improves large model training by improving scale, speed, cost and usability — unlocking the ability to train models with over 100 billion parameters. One piece of the DeepSpeed library, ZeRO 2, is a parallelized optimizer that greatly reduces the resources needed for model and data parallelism while massively increasing the number of parameters that can be trained. DeepSpeed is open-sourced at https://github.com/microsoft/DeepSpeed.
You can learn more about them in this blog post from February 2020, and this update on ZeRO from May 2020.
DeepSpeed ZeRO-2
E em setembro de 2020, a Microsoft apresentou ZeRO-2!
Aqui está uma apresentação do DeepSpeed ZeRO-2 da Microsoft (post: “DeepSpeed: Extreme-scale model training for everyones”):
In February, we announced DeepSpeed, an open-source deep learning training optimization library, and ZeRO (Zero Redundancy Optimizer), a novel memory optimization technology in the library, which vastly advances large model training by improving scale, speed, cost, and usability. DeepSpeed has enabled researchers to create Turing Natural Language Generation (Turing-NLG), the largest language model with 17 billion parameters and state-of-the-art accuracy at the time of its release. In May, we released ZeRO-2 — supporting model training of 200 billion parameters up to 10x faster compared to state of the art — along with a list of compute, I/O, and convergence optimizations powering the fastest BERT training. From there, we have been continuing to innovate at a fast rate, pushing the boundaries of speed and scale for deep learning training.
A questão que surge então é como implementar esse método mágico que diminui tanto o tempo para treinar um modelo Transformer (modelo mais comum que é usado no NLP)?
Muito simples!
Por exemplo, se estiver usando a biblioteca Transformers da Hugging Face a partir da versão v4.2.0, basta ler este post de janeiro de 2021 “Fit More and Train Faster With ZeRO via DeepSpeed and FairScale” (e em particular, este paragrafo: “Fitting A Huge Model Onto One GPU”) e a documentação da Hugging Face (“Deployment with one GPU” e “Deployment in Notebook”) ssobre DeepSpeed.
Assim, poderá usar DeepSpeed no seu notebook Colab mesmo com apenas um GPU!
Aqui estão as etapas e códigos correspondentes:
- Instale e importe as versões mais recentes (e ainda em desenvolvimento) da biblioteca Transformers da Hugging Face pelo comando seguinte: !pip install datasets git+https://github.com/huggingface/transformers/, e depois import transformers
- Instale e importe DeepSpeed pelo comando seguinte: !pip install deepspeed, e depois import deepspeed
- Como DeepSpeed requer um ambiente distribuído mesmo quando apenas um GPU é usado, precisa emular um iniciador no notebook (exemplo de código neste paragrafo deste post da Hugging Face).
- Crie um arquivo ds_config.json de configuração DeepSpeed (exemplo de código neste paragrafo deste post da Hugging Face) com “cpu_offload”: False
- Adicione o seguinte argumento aos argumentos do TrainingArguments: deepspeed=”ds_config.json”
Verifique o nosso notebook no Colab para ver o código!
Conclusão
Et voilà!
Agora tem todas as técnicas para treinar um modelo de NLP com um único GPU (no Google Colab, por exemplo), bem como um notebook com o código correspondente.
Resta-nos colocar tudo isso em prática. Por isso, vou publicar rapidamente um modelo de NLP usando todas essas técnicas. Permaneça conectado;)
Sobre o autor: Pierre Guillou é consultor de IA no Brasil e na França, pesquisador em Deep Learning e NLP do AI Lab (Unb) e professor de Inteligência Artificial (UnB). Entre em contato com ele por meio de seu perfil no LinkedIn.
