NLP nas empresas | Uma solução para colocar os modelos BERT em produção com Adapters para transformers

O gráfico do processo AdapterHub. Os adapters Φ são introduzidos em um transformer pré-treinado Θ (etapa ①) e são treinados (②). Eles podem então ser extraídos e abertos (③) e visualizados (④). Adapters pré-treinados são baixados instantaneamente (⑤) e costurados em um modelo que é usado para inferência (⑥) (source: AdapterHub: A Framework for Adapting Transformers)

Qualquer organização (empresa do setor público ou privado) possui muitos processos internos e externos que hoje podem ser automatizados através do uso de modelos de Inteligência Artificial (IA) e, em particular, modelos de NLP (Natural Language Processing, ou PLN: Processamento de Linguagem Natural). Infelizmente, quando tem que gerenciar tantos modelos quanto processos, os problemas de usar tais modelos na produção (além daqueles relacionados ao seus treinamentos) desmotiva a maioria das organizações. Adapters que, ao contrário, permitem o uso de um único modelo NLP do tipo BERT, fornecem uma solução prática para essa situação. Após a revolução do NLP de 2018, os Adapters trazem os modelos de NLP para a vida cotidiana das organizações.

Outros artigos a ler:

• NLP nas empresas | Como ajustar um modelo de linguagem natural como BERT a um novo domínio linguístico com um Adapter?
• NLP nas empresas | Como ajustar um modelo de linguagem natural como BERT para a tarefa de classificação de tokens (NER) com um Adapter?
• NLP nas empresas | Como ajustar um modelo de linguagem natural como BERT para a tarefa de Question-Answering (QA) com um Adapter?
• NLP nas empresas | Como criar um modelo BERT de Question-Answering (QA) de desempenho aprimorado com AdapterFusion?
• NLP nas empresas | Adapter-Transformers Para Dummies

Sumário

• O desafio da IA ​​para empresas
• O caso do NLP nas empresas
• Modelo de linguagem de domínio específico (Domain-specific)
• Modelo de linguagem de domínio geral pré-treinado (pretrained general-domain language model)
• Tudo bem? Não!
• Adapters para modelos transformers de NLP
• (opção) Adicione seus próprios adapters pré-treinados ou arquiteturas ao Adapter Hub
• Referências

O desafio da IA ​​para empresas

A Inteligência Artificial (IA) está ganhando manchetes na mídia.

Modelos de visão computacional (baseados principalmente em uma arquitetura ConvNet) são cada vez mais usados ​​para reconhecimento facial e detecção / reconhecimento de todos os tipos de objetos por exemplo.

No campo da linguagem natural (NLP ou Natural Language Processing), os modelos baseados em uma arquitetura Transformer são usados ​​para realizar tarefas linguísticas como tradução, classificação de frases / documentos, sínteses, busca de respostas ou entitades, e até mesmo a geração de novos textos!

Nessas 2 áreas em particular (visão e linguagem), as bibliotecas de código aberto (Open Source) permitem baixar modelos já treinados e adaptá-los às novas necessidades por meio de ajuste fino (fine-tuning). Isso é chamado de Transferência de Aprendizagem (Transfer Learning) ou poder se beneficiar da aprendizagem já adquirida para especializar um modelo para uma nova tarefa ou um novo domínio linguístico. No caso do NLP, a gente pode citar as bibliotecas datasets, tokenizers e transformers da Hugging Face.

Outras bibliotecas, como DeepSpeed ​​da Microsoft, otimizam o treinamento desses modelos reduzindo sua duração e permitindo o uso de um único GPU.

Além disso, as ofertas de GPU online se multiplicaram, reduzindo seus custos até zero no caso dos notebooks do Google Colab.

Assim, se a democratização da IA ​​se tornar uma realidade em 2021, ainda existem 3 problemas para qualquer empresa que deseje utilizar modelos de IA em seus processos internos ou de negócios:

1. a necessidade de bancos de dados (datasets) de qualidade e quantidade suficiente para refinar esses modelos pré-treinados de acordo com as suas novas necessidades;
2. o treinamento ou fine-tuning dos modelos de NLP com esses bancos de dados;
3. a produção e manutenção desses modelos ajustados quando o tamanho no disco de um único modelo de NLP excede hoje o GB.

O caso do NLP nas empresas

Todas as empresas desejam se beneficiar dos progressos dos modelos de IA em NLP para automatizar seus processos internos e externos, reduzir o custo de processamento de informações, melhorar seus processos clientes, aumentar suas vendas por meio de um melhor direcionamento e até mesmo inovar, oferecendo, por exemplo, um chatbot para seus clientes.

Como lembramos no parágrafo anterior, todos podem aproveitar os modelos de NLP já treinados gratuitamente por outros (como Google ou Facebook), mas esses devem ser adaptados. E é aí que reside a dificuldade.

Vamos dar um exemplo.

A empresa que chamaremos BRASIOJE vende produtos de bem-estar. Só vende na Internet por meio de seu site e sites de revendedores. Ela usa enormemente as mídias sociais para detectar tendências, promover sua marca e realizar marketing direcionado.

Através dos seus diversos canais online, o seu serviço de atendimento ao cliente recebe mensagens de todo o tipo (pedido de compra, reclamação, etc.) que deve poder classificar automaticamente para as encaminhar para os respectivos departamentos. Portanto, é necessário criar um banco de dados (dataset) onde cada mensagem seja rotulada com os rótulos que a qualificam. Esse banco de dados servirá para treinar um classificador que será capaz de rotular automaticamente cada nova mensagem. Esse banco de dados também pode ser usado para criar listas temáticas de Perguntas Frequentes que podem ser usadas para treinar um modelo de tipo QA (Question-Answering) para encontrar automaticamente a resposta a uma mensagem.

Pegue outro departamento. O seu departamento de marketing deve ser capaz de verificar a partir da definição textual de um produto se ele já existe entre seus concorrentes. Portanto, é necessário criar um banco de dados com as descrições desses produtos. Esse banco de dados será usado para treinar um modelo de linguagem que pode então ser especializado para detectar as semelhanças entre uma nova descrição de produtos e as existentes.

Essa análise rápida das necessidades dos modelos de NLP para automatizar os processos pode ser aplicada a qualquer empresa, a todos os seus departamentos e a todos os seus processos (aconselhamos os interessados ​​nesse tipo de análise a seguir o curso de Andrew NG: IA para todos).

Assim, o principal elemento que surge é a necessidade de se dispor de bancos de dados textuais especializados para diferentes necessidades. Existem então 2 hipóteses:

1. ou o banco de dados criado é grande (mais de 1 GB),
2. ou não.

Na maioria dos casos (e em particular no início da constituição de um banco de dados), esse é de pequena dimensão.

Além disso, entendemos da análise anterior que é necessário constituir tantos bancos de dados quantos forem os processos a ser automizados por um modelo de IA. Portanto, existem tantos modelos para treinar quanto bancos de dados.

Como fazer isso? Como treinar esses modelos? Como acessar a esses modelos rapidamente em produção e como mantê-los atualizados?

Antes de oferecer uma solução prática para essas questões, vamos resolver o caso de um grande banco de dados.

Modelo de linguagem de domínio específico (Domain-specific)

Treinar um modelo de NLP com uma grande quantidade de dados obtém os melhores resultados. Na verdade, isso torna possível criar um vocabulário específico para esses dados e, então, treinar um modelo de linguagem a partir do zero, que então se especializará no campo linguístico de dados de treinamento.

Um bom exemplo desse processo é detalhado neste artigo da Microsoft (Domain-specific language model pretraining for biomedical natural language processing, agosto de 2020), cujo modelo especializado com documentos médicos supera todos os outros modelos de NLP na área médica, modelos que passaram pelo processo clássico de transferência de aprendizagem (Transfer Learning) de um modelo já treinado a partir de um corpus geral de textos da Web e da Wikipedia.

Dois paradigmas para o pré-treinamento do modelo de linguagem natural. Superior: o paradigma de domínio misto predominante assume que o texto de domínio externo ainda é útil e normalmente inicializa o pré-treinamento específico de domínio com um modelo de linguagem de domínio geral e herda seu vocabulário. Abaixo: o pré-treinamento específico do domínio do zero deriva o vocabulário e conduz o pré-treinamento usando apenas texto no domínio (credito: Domain-specific language model pretraining for biomedical natural language processing)

No entanto, o problema é óbvio: primeiro você deve criar um banco de dados muito grande e, em seguida, ter uma capacidade de computação significativa para treinar desde zero um modelo de linguagem natural antes de poder ajustar esse modelo para tarefas diferentes. Muito poucas empresas serão capazes de fazer isso para os diferentes modelos que devem treinar.

Modelo de linguagem de domínio geral pré-treinado (pretrained general-domain language model)

Portanto, voltamos à situação mais comum: a partir de um modelo de linguagem já treinado em um corpo geral de textos de tipo Wikipedia, é possível ajustar esse modelo para realizar uma tarefa de NLP (classificação, resposta a uma pergunta, detecção de entidade, etc. ) com um novo banco de dados. A vantagem é que ele não precisa ser grande e o treinamento pode ser feito em poucas horas.

Por meio do treinamento, os embeddings dos tokens do vocabulário do modelo pré-treinado serão ajustados ao contexto dos textos do novo banco de dados. Embora esse ajuste não funcione tão bem quanto o treinamento de um vocabulário específico, o modelo resultante pode ser usado na produção.

Um artigo de Sebastian Ruder apresenta claramente esses 2 métodos complementares que são o Transfer Learning e o ajuste fino (fine-tuning): Recent Advances in Language Model Fine-tuning (fevereiro de 2021).

Processo de fine-tuning de um modelo de linguagem natural para uma tarefa de NLP (credito: Recent Advances in Language Model Fine-tuning)

Tudo bem? Não!

Voltemos ao nosso exemplo anterior da empresa BRASIOJE e do seu serviço de atendimento ao cliente que após muitos esforços possui vários bancos de dados temáticos de perguntas e respostas (sobre a empresa, sobre os seus produtos, sobre o serviço pós-venda, etc.).

Se seguirmos o processo clássico lembrado acima, seu departamento de IA terá que refinar um modelo geral da língua portuguesa (por exemplo, o da Neuralmind de base ou large) com cada um dos bancos de dados à sua disposição, o que gerará um modelo por banco de dados.

Terá então que colocar todos esses modelos no servidor de produção, sabendo que o modelo BERT de melhor desempenho (large) pesa mais de 1 GB. Em seguida, terá que criar uma API de conexão para cada modelo e verificar se o tempo de resposta de seu servidor de produção é aceitável, mesmo no caso de várias solicitações em paralelo.

Adapters para modelos transformers de NLP

Uma biblioteca recente baseada em estratégias de pesquisa publicadas (veja os artigos nas Referências), que tem uma documentação online, notebooks e um hub de compartilhamento de módulos (AdapterHub), e que usa a biblioteca de NLP a mais usada (transformers da Hugging Face) fornece uma solução elegante e prática para esse problema da multiplicidade de modelos ajustados para serem mantidos por uma empresa.

Essa é a biblioteca de adapter-transformers.

biblioteca adapter-transformers

Aqui estão as principais ideias:

• o método clássico de ajustar um modelo geral de tipo BERT para uma tarefa de NLP a partir de um novo banco de dados corre o risco de destruir o aprendizado presente em embeddings e parâmetros das camadas do modelo, atualizando seus valores (se chama Catastrophic Forgetting);
• mantendo os valores de seus parâmetros intactos e treinando apenas poucos novos parâmetros no nível de cada camada do modelo de linguagem (cujo número total é de aproximadamente 3% daquele do modelo geral), é possível alcançar um desempenho equivalente ao obtido pelo método clássico (um pouco como se complementássemos o aprendizado geral por um aprendizado particular);
• agrupando esses novos parâmetros em um módulo chamado Adapter, que pode ser carregado no modelo geral por uma única linha de código, é suficiente armazenar apenas um modelo geral de NLP no servidor de produção e não um por banco de dados.

Et voilà :-)

Nota: para apresentar casos concretos de uso de Adapters, em breve publicaremos notebooks / scripts que poderá utilizar em sua empresa.

(opção) Adicione seus próprios adapters pré-treinados ou arquiteturas ao Adapter Hub

[ link para o tutorial ] Aqui está o conteúdo (em inglês) do tutorial publicado no Adapter Hub com informações adicionais.

Getting started

[ link para o parágrafo ]

1. Fork the Adapter Hub repository by clicking the ‘Fork’ button on the repository’s page. This creates a clone of the repository under your GitHub user.
2. Clone your fork to your local file system:

git clone https://github.com/github_username/Hub.git
cd Hub/

3. Set up the Python environment. This includes the adapter-hub-cli which helps in preparing your adapters for the Hub.

# active conda
source /mnt/home/username/anaconda3/bin/activate
# create and activate a virtual environment
conda create -n adapter-transformers-cli python=3.8
# activate your virtual environment
conda activate adapter-transformers-cli
# install pytorch
conda install pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c nvidia
# install Adapter CLI
pip install -U ./scripts/.
# installation results
Successfully installed PyInquirer-1.0.3 Pygments-2.9.0 adapter-hub-cli-0.1.0 adapter-transformers-2.0.1 attrs-21.2.0 chardet-4.0.0 click-8.0.1 colorama-0.4.4 filelock-3.0.12 idna-2.10 joblib-1.0.1 jsonschema-3.2.0 numpy-1.21.0 packaging-20.9 prompt-toolkit-1.0.14 pyparsing-2.4.7 pyrsistent-0.18.0 pyyaml-5.4.1 regex-2021.7.1 requests-2.25.1 ruamel.yaml-0.17.10 ruamel.yaml.clib-0.2.4 sacremoses-0.0.45 six-1.16.0 tokenizers-0.10.3 tqdm-4.61.1 urllib3-1.26.6 wcwidth-0.2.5

Add your pre-trained adapter

[ link para o parágrafo ]

1. After the training of your adapter has finished, we first would want to save its weights to the local file system:

model.save_adapter("/path/to/adapter/folder", "your-adapter-name")

2. Pack your adapter with the adapter-hub-cli. Start the CLI by giving it the path to your saved adapter:

adapter-hub-cli pack /path/to/adapter/folder

adapter-hub-cli will search for available adapters in the path you specify and interactively lead you through the packing process.

Note: the configuration of the adapter is specified by an identifier string in the YAML file. This string should refer to an adapter architecture available in the Hub. If you use a new or custom architecture, make sure to also add an entry for your architecture to the repo.

Here the informations that will be displayed in your terminal during the packing process (replace /path/to/adapter-folder by the path to your adapter folder):

(adapter-transformers-cli) userprompt:~$ adapter-hub-cli pack /path/to/adapter-folder
========== Step 1: Found models and adapters ==========
Adapter in /path/to/adapter-folder
What would you like to do?  
- Extract adapters from found models & pack all found adapters
>> Pack all found adapters
- Exit
========== Step 2: Packing 1 adapters ==========
Downloading template...
[i] Before we start packing your adapters, we first need some meta information.
This information will be added to every adapter info card.
Prompts starting with '[opt.]' are optional. Skip them if not applicable.
? Your name or the names of other authors:  <author(s) name>
? An email address to contact you or other authors:  <author(s) email>
? [opt.] A URL providing more information on you or your work:  <url>
? [opt.] Your or your organization's Twitter handle:  <twitter url>
? [opt.] Your or your organization's GitHub account:  <github url>
? [opt.] A template for the download links of your adapters:
Thanks! Now let's start...
[Adapter 1 of 1] /path/to/adapter-folder
? The type of adapter:  <Task or Lang>
? The identifier of the task:  <qa for example>
? The identifier of the subtask:  <dataset_name>
? The name of the adapter config:  <adapter config like pfeiffer or houlsby>
Zipping /path/to/adapter-folder to .PACK_OUTPUT/adapter-folder.zip...
✔ Created info card for adapter-folder
========== Step 3: Finalization & Upload ==========
Great! We have successfully packed all adapters.
These are your next steps for publishing them on AdapterHub:
-> Upload the created zip folders to your server.
-> Add the download links to your adapters to the respective yaml info cards.
-> Add additional information to your info cards. Description and citation are very useful!
-> Open a pull request to https://github.com/adapter-hub/Hub to add your info cards.

3. After step 2, a zipped adapter package and a corresponding YAML adapter card should have been created.

• Upload the zip package to your server space and move the YAML file into a subfolder for your user/ organization in the adapters folder of the cloned Hub repository.
• In the YAML adapter card, consider filling out some additional fields not filled out automatically, e.g. a description of your adapter is very useful! Especially make sure to set a download URL pointing to your uploaded zip package.

4. (optional) After you completed filling the YAML adapter card, you can perform some validation checks to make sure everything looks right:

adapter-hub-cli check adapters/<your_subfolder>/<your_adapter_card>.yaml

5. Almost finished: Now create a pull request from your fork back to our repository.

1. We will perform some automatic checks on your PR to make sure the files you added are correct and the provided download links are valid. Keep an eye on the results of these checks!
2. That’s it! Your adapter will become available via our website as soon as your pull request is accepted! 🎉🚀

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.

Referências

• Jonas Pfeiffer, Ivan Vulic, Iryna Gurevych, Sebastian Ruder (2021). UNKs Everywhere: Adapting Multilingual Language Models to New Scripts. https://arxiv.org/abs/2012.15562
• Pfeiffer, J., Kamath, A., Rücklé, A., Cho, K., & Gurevych, I. (2021). AdapterFusion: Non-Destructive Task Composition for Transfer Learning. EACL 2021, https://www.aclweb.org/anthology/2021.eacl-main.39.pdf
• Rücklé, A., Geigle, G., Glockner, M., Beck, T., Pfeiffer, J., Reimers, N., & Gurevych, I. (2020). AdapterDrop: On the Efficiency of Adapters in Transformers. ArXiv, https://arxiv.org/abs/2010.11918
• Pfeiffer, J., Vulic, I., Gurevych, I., & Ruder, S. (2020). MAD-X: An Adapter-based Framework for Multi-task Cross-lingual Transfer. EMNLP 2020, https://www.aclweb.org/anthology/2020.emnlp-main.617/
• Pfeiffer, J., Rücklé, A., Poth, C., Kamath, A., Vulić, I., Ruder, S., Cho, K., & Gurevych, I. (2020). AdapterHub: A Framework for Adapting Transformers. EMNLP 2020 https://www.aclweb.org/anthology/2020.emnlp-demos.7.pdf
• Houlsby, N., Giurgiu, A., Jastrzebski, S., Morrone, B., Laroussilhe, Q.D., Gesmundo, A., Attariyan, M., & Gelly, S. (2019). Parameter-Efficient Transfer Learning for NLP. ICML 2019, http://proceedings.mlr.press/v97/houlsby19a/houlsby19a.pdf
• Wolf, T., Debut, L., Sanh, V., Chaumond, J., Delangue, C., Moi, A., Cistac, P., Rault, T., Louf, R., Funtowicz, M., & Brew, J. (2019). Transformers: State-of-the-Art Natural Language Processing. EMNLP 2020, https://www.aclweb.org/anthology/2020.emnlp-demos.6/