Hugging Face: aprimorando eficiência de modelos com Optimum

Iniciando no Optimum - Apresentação

Você já sabe utilizar o Transformer do Hugging Face e quer saber como pode melhorar o desempenho desses modelos?

Venha comigo conhecer e explorar também o Optimum, que também é do Hugging Face.

Muito prazer em te conhecer. Sou Mirla, instrutora da Alura e vou te acompanhar nesse curso.

Audiodescrição: Mirla é uma mulher de pele branca e cabelos pretos cacheados na abaixo do ombro. Usa óculos de grau com armação redonda. Está com uma camiseta preta. Ao fundo, uma parede lisa com duas prateleiras com livros e objetos, a iluminação é degradê do verde para azul.

Durante nosso curso, trabalharemos em uma startup fictícia que produz projetos relacionados ao mercado financeiro. Lidamos com muitas informações, de modo que qualquer projeto com Transformers demora muito tempo para ser executado, sobrecarregando nosso sistema. Então, nossa missão é diminuir a sobrecarga, buscando aumentar a eficiência dos nossos modelos, diminuindo a velocidade deles no processamento.

Nossa missão: diminuir a sobrecarga e aumentar eficiência dos modelos

Para fazer isso, vamos utilizar o Python e também o Hugging Face, com as extensões do Optimum e do Transformers.

Pré-requisitos

Para que você tenha um bom aproveitamento desse curso, recomendamos que você já saiba Python e também já tenha tido experiências com o Transformers do Optimum.

E então, vamos começar?

Iniciando no Optimum - Utilizando o Optimum

Trabalhamos em uma startup que produz soluções para empresas internacionais relacionadas ao mercado financeiro. Aqui, produzimos modelos, disponibilizamos dados e atendemos nossos clientes.

Atualmente, a equipe de dados está desenvolvendo um sistema de classificação de notícias relacionadas ao mercado financeiro.

Para fazer isso, utilizamos nossos dados da empresa, que aumentam cada vez que recebemos uma nova notícia, e também um modelo pré-treinado do Hub do Hugging Face.

O problema é que, por termos um grande conjunto de dados, o poder para fazer as inferências, instanciamento do modelo, já exige um custo das nossas máquinas.

Para equilibrar esse custo, seria interessante termos um modelo eficiente, ou seja, que tenha uma alta precisão e um custo operacional menor, mas sem perder essa alta precisão, esse modelo mais balanceado e eficiente. Infelizmente, não é isso que temos agora com o modelo que estamos utilizando.

Então, o que precisamos fazer agora é melhorar esse modelo.

Para fazer isso, podemos utilizar o Optimum, que é uma extensão do Transformers que fornece ferramentas para a otimização de desempenho dos nossos modelos, para diferentes hardwares específicos.

Vamos para o nosso Colab para fazermos esse uso?

Vamos utilizar este notebook para desenvolver todo o projeto, e você pode baixá-lo para fazermos o projeto juntos.

Instalando bibliotecas

Primeiro, precisamos instalar algumas bibliotecas que não são nativas no Google Colab. E para isso, já deixei um código aqui para fazermos o pip install do que precisaremos:

!pip install optimum transformers datasets evaluate huggingface_hub transformers[sklearn] optimum[onnxruntime]

Vamos executar essa célula para já fazermos essa instalação. Pode demorar cerca de um minuto.

Já fizemos a instalação de todas as nossas bibliotecas. Agora, vamos atrás desse modelo que precisamos otimizar e melhorar.

Já deixei disponível aqui o ID do nosso modelo. Deixamos ele como uma string, que é como o nosso modelo vai ser instanciado. Precisamos de um ID. Então, vou rodar essa célula aqui para já salvar essa string com o nosso modelo.

modelo_id_tc = 'ahmedrachid/FinancialBERT-Sentiment-Analysis'

Tokenização

Em seguida, vamos fazer a tokenização dele. Para fazermos a tokenização, é simples. Podemos utilizar a biblioteca Transformers, que já estamos acostumados.

from transformers import AutoTokenizer

Podemos executar essa célula.

E aí, podemos pegar o tokenizer para criar o nosso tokenizer que vai armazenar os tokens desse modelo:

tokenizer = AutoTokenizer.from_pretrained(modelo_id_tc)

Vamos executarmos essa célula. Com isso, ele fez a coleta de todos os nossos tokens.

Instanciamento

Agora, podemos instanciar o nosso modelo.

Para fazermos esse instanciamento, não vamos utilizar mais os Transformers. Agora, vamos utilizar o Optimum.

Mas o Optimum provém de vários pacotes para utilizarmos em vários hardwares especializados. O pacote que vamos utilizar é o ONNX Runtime, que fornece diversas ferramentas para otimização, quantização, para acelerar o treinamento. E ele funciona perfeitamente aqui no Colab. Então, vamos utilizá-lo.

Vamos fazer um import do onnxruntime e de um método para fazer o instanciamento do nosso modelo. Com o modelo atual é de classificação de texto, vamos importar um método que consegue instanciar um modelo de classificação de texto, o ORTModelForSequenceClassification:

from optimum.onnxruntime import ORTModelForSequenceClassification

Agora, vamos criar uma variável modelo_tcque será igual a ORTModelForSequenceClassification.from_pretrained(modelo_id_tc, export = True).

modelo_tc = ORTModelForSequenceClassification.from_pretrained(modelo_id_tc, export = True)

Por que igual a true? Porque esse modelo não é da conta do Optimum, é de outro. Então, vamos ter que exportá-lo. Vou dar um "Shift + Enter" para executar essa célula.

E assim que ele for exportado, já podemos também salvar esse modelo aqui nas pastas do Colab, junto com seus tokens.

Para podermos salvar os tokens, é bem simples. Colocamos o nosso tokenizer seguido de .save_pretrained(dir_tc). Entre parênteses colocamos o local em que queremos salvar.

No dir_tc = 'tmp/onnx-text/' definimos o diretório no qual serão salvos os modelos do nosso classificador de texto. Você pode alterar o nome e deixar como preferir.

dir_tc = 'tmp/onnx-text/'

tokenizer.save_pretrained(dir_tc)
modelo_tc.save_pretrained(dir_tc)

Podemos executar essa célula.

Abrindo a estrutura de pastas no painel lateral, já vemos que foi criada a pasta temporária. Ao abrir ela, vamos ter o onnx-text. Vamos ter todos os tokenizers e também o nosso modelo. Veja que ele vai ter extensão .onnx, que é a extensão do Optimum que vamos utilizar.

Próximo passo

Temos o modelo salvo dentro do nosso Colab. E como vamos utilizar esse modelo? Será que é do mesmo jeito que fazemos lá no Transformers? Vamos aprender no próximo vídeo!

Iniciando no Optimum - Inferindo o modelo Optimum

Já realizamos a tokenização, inferência e também já salvamos o nosso modelo Optimum. No entanto, não adianta fazer tudo isso e não conseguir utilizar esse modelo, ou seja, inferir ele.

Uma forma de utilizar esse modelo e obter resultados dele é utilizando um pipeline), que o próprio Optimum oferece.

Vamos acessar o Colab para conseguirmos fazer essa inferência.

Para podermos utilizar a função pipeline, precisamos importar essa função. Então, vamos digitar e executar o seguinte:

from optimum.pipelines import pipeline

Agora, precisamos entender um pouco como funciona o nosso modelo.

Temos um modelo de classificação de texto, o que isso significa? Enviamos para ele uma frase relacionada ao mercado financeiro, uma notícia relacionada ao mercado financeiro, e ele retorna uma categoria do tom dessa notícia. Se é um tom positivo, se é um tom negativo, se é um tom neutro, um tom, entre aspas, que é como se fosse um sentimento, ele indica o que essa frase quer dizer.

Por isso, dizemos que esse é um modelo de classificação de texto. Precisamos ter isso em mente para conseguirmos desenvolver uma pipeline coerente.

Vamos desenvolver, já que entendemos como ele funciona.

Desenvolvendo pipeline

Vamos atribuir essa pipeline a uma variável que vou definir como onnx_tc, que é de text classification. Igual a nossa função de pipeline, vamos abrir parênteses e definir qual é a função desse modelo.

Após as aspas, vamos colocar uma vírgula porque precisamos definir qual é o modelo que vamos colocar dentro dessa pipeline. Então, colocamos model= modelo_tc, que foi o modelo que instanciamos.

Após a vírgula, vamos definir o tokenizer, que também já instanciamos. O parâmetro para fazer isso é o tokenizer mesmo, e vamos dizer que é igual ao tokenizer, nossa variável. Por último, vamos definir o accelerator como ORT, até porque foi a partir dele que instanciamos.

from optimum.pipelines import pipeline

onnx_tc = pipeline('text-classification',model=modelo_tc,tokenizer=tokenizer,accelerator='ort')

Agora, precisamos configurar a frase que essa pipeline vai receber. Podemos usar a seguinte frase:

As tendências do mercado indicam uma perspectiva positiva para as empresas farmacêuticas.

Nós, que somos humanos e lemos essa frase, já entendemos que o tom dessa frase, o sentimento que ela traz, é um sentimento positivo, é um tom positivo.

Para podermos, executar essa pipeline, vamos utilizar uma função que vai executar e rodar essa pipeline para nós.

Vamos definir a função com def e chamá-la de text_class.

Dentro dos parênteses, vamos definir o que vamos estar utilizando para executar essa pipeline. Então, vamos colocar o onnx_pipe e a nossa frase.

Dentro da nossa função, vamos salvar a saída em uma variável chamada saida, igual o nosso modelo, que seria a nossa pipeline, que é o onnx_pipe. E dentro dos parênteses, vamos enviar a frase, que é a variável onde a frase está salva.

Por fim, precisamos fazer essa função retornar um valor de saída.

def text_class(onnx_pipe,frase=frase):
  saida = onnx_pipe(frase)
  return saida

Podemos executar essa função especificando dentro do parênteses a pipeline que acabamos de criar.

text_class(onnx_tc)

Não precisamos especificar a frase, porque já configuramos lá, definimos, e vamos rodar aqui e verificar a saída. Tivemos a seguinte saída:

[{'label': 'positive', 'score': 0.9998509883880615}]

Como esperado, temos um resultado positivo. Ele também retornou a porcentagem de certeza, pelo score dele, que deu quase um.

Próximo passo

A partir desse resultado, podemos entender que o modelo melhorado, o modelo eficiente desse mesmo modelo que estamos utilizando agora, mantém esse mesmo score, mantém essa mesma certeza, só que ele deve encontrar esse resultado de uma forma mais rápida. tempo de processamento dele deve ser menor do que esse que executamos.

Com isso, já sabemos como podemos utilizar um modelo Optimum para salvar, inferir e instanciar. E podemos utilizar isso dentro dos projetos da startup.

Na próxima aula, vamos descobrir como melhorar a eficiência desse modelo!

Sobre o curso Hugging Face: aprimorando eficiência de modelos com Optimum

O curso Hugging Face: aprimorando eficiência de modelos com Optimum possui 110 minutos de vídeos, em um total de 43 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Iniciando no Optimum
• Otimizando um modelo Optimum
• Verificando a otimização
• Quantizando um modelo QA
• Avaliando o modelo quantizado