A ideia de medir a facilidade de leitura não é nova. Desde a década de 1950, pesquisadores da área de linguística vêm propondo fórmulas que tentam traduzir essa percepção em números. Mesmo assim, esses índices ainda são pouco utilizados em NLP, apesar de serem bastante úteis para trabalhar com grandes volumes de texto.

Esse conceito pode ser encontrado com outros nomes, como leiturabilidade ou apreensibilidade. Em suma, esses conceitos buscam responder uma mesma pergunta: quão fácil é ler este texto? Para isso, utilizam métricas que ajudam a classificar o nível de dificuldade de leitura de forma mais padronizada.

Neste artigo, vamos explorar os principais índices de legibilidade, algumas bibliotecas que facilitam sua aplicação e exemplos práticos de como essa abordagem pode apoiar o trabalho com NLP no dia a dia.

Como a Legibilidade é calculada?

De forma geral, as métricas de legibilidade se baseiam em três elementos principais: a quantidade de frases em um texto, o número de palavras por frase e a complexidade das palavras utilizadas. A lógica é relativamente simples: quanto mais longas forem as frases e quanto mais complexas forem as palavras, maior tende a ser a dificuldade de leitura.

O que varia entre os diferentes índices é justamente a forma de definir essa “complexidade”. Dependendo do modelo, ela pode ser medida por número de sílabas, quantidade de caracteres ou até mesmo por regras específicas de cada língua.

Vejamos agora uma lista com os alguns índices e suas características:

• Flesch reading ease — Índice de legibilidade de Flesch:
  Baseia-se na quantidade de palavras em uma frase e na complexidade das palavras utilizadas. É um dos índices mais conhecidos e amplamente utilizados.
• Gunning fog index — Índice de Nebulosidade de Gunning:
  Foi um dos primeiros a propor uma escala que estima o nível de educação formal necessário para compreender um texto. Considera frases longas e palavras complexas, definidas, nesse caso, como aquelas com três ou mais sílabas.
• ARI (Automated readability index ) — Índice de Legibilidade Automatizado:
  Semelhante aos anteriores, mas com uma diferença importante: em vez de utilizar sílabas (que podem ser difíceis de mensurar e nem sempre consensuais), utiliza o número de caracteres por palavra como forma de mensurar sua complexidade, tornando o cálculo mais direto.
• Flesch–Kincaid grade level — Nível de Instrução de Flesch-Kincaid:
  Nada mais é que a fórmula de Flesch reformulada para uma escala de níveis de instrução.
• Coleman–Liau index — Índice de Coleman-Liau:
  Diferencia-se principalmente pela forma de calcular a complexidade das frases. Em vez de trabalhar com a razão “palavras por sentença”, utiliza a proporção inversa (“sentenças por palavras”), além de considerar o número de caracteres.
• Índice Gulpease:
  Este índice é interessante pois foi desenvolvido para a língua italiana, é um exemplo de índice adaptado linguisticamente. Assim como o ARI, não depende da contagem de sílabas para estimar a complexidade.

O resultado dos índices é fornecido em forma de escalas, que podem ser de 0 ~ 100 ou então de 0 ~ 20. Os resultados próximos à zero representam os textos mais complexos, enquanto 100 seria um texto muito simples.

Vale atenção especial aos índices que expressam o resultado em termos de anos de escolaridade: nesses casos, a interpretação se inverte — valores mais altos indicam textos mais difíceis, que exigem maior nível de instrução.

Atenção:

• Embora os índices normalmente operem dentro de faixas definidas, em alguns casos os valores podem ultrapassar esses limites ou até assumirem valores negativos.
• Cada língua possui (ou deveria possuir) adaptações específicas dessas fórmulas, considerando suas particularidades linguísticas. A aplicação de fórmulas não adaptadas pode gerar métricas não confiáveis.

Bibliotecas

Agora vamos ver algumas bibliotecas disponíveis que realizam o cálculo de legibilidade:

Inglês

No caso do inglês, a biblioteca Readability na linguagem python permite a aplicação de todos os índices citados (com exceção do índice de Gulpease, por ser elaborado para o italiano), além de outros índices, não citados neste artigo.

Mais do que apenas calcular métricas, a biblioteca também oferece funcionalidades auxiliares importantes, como contagem de sílabas, identificação de palavras complexas, segmentação de parágrafos e outras análises úteis para estudos de legibilidade.

Português

Para o português, uma ferramenta bastante interessante é o ALT, desenvolvido já com as fórmulas adaptadas à língua. Essa adaptação é importante, já que características linguísticas impactam diretamente o cálculo da legibilidade.

Interessante notar que ao final o resultado é impresso na gradação de 0 ~ 20 pois o ALT se utiliza da média dos índices de Flesch-Kincaid, Gunning fog, ARI e Coleman-Liau para a métrica final.

Além do cálculo em si, o software também fornece explicações e insights sobre o texto analisado. Ele destaca, por exemplo, palavras consideradas complexas e frases muito longas que poderiam ser divididas para melhorar a fluidez da leitura.

Para ilustrar, realizamos um teste com uma review de jogo, buscando observar como a ferramenta se comporta em textos com presença de palavras estrangeiras e gírias:

Caso o tema seja de interesse, vale a pena explorar tanto o site quanto o artigo publicado pela ferramenta, especialmente pela riqueza de detalhes sobre legibilidade e pelas discussões sobre adaptações necessárias para o português.

Uso e aplicação prática das métricas de legibilidade

Depois de entender os índices e as ferramentas disponíveis, vale voltar à pergunta inicial: o que, de fato, podemos fazer com tudo isso?

Um primeiro uso (e talvez o mais imediato) é avaliar os próprios textos. Este artigo, por exemplo, recebeu o nível 13 “Média legibilidade.
Dificuldade média. Pode ser bem compreendido por universitários em início de graduação.”. Mais do que um número isolado, esse tipo de métrica ajuda a refletir sobre escolhas de escrita e a ajustar o nível de complexidade de acordo com o público desejado.

Mas o valor das métricas de legibilidade vai além do uso de um único texto. Dentro da área de NLP, elas se tornam especialmente úteis na análise de datasets textuais, principalmente quando lidamos com corpus muito grandes. Entender o nível médio de legibilidade de um conjunto de dados pode trazer insights importantes sobre o tipo de linguagem presente ali e, consequentemente, sobre o comportamento esperado dos modelos treinados com esses dados.

Em um cenário cada vez mais marcado pela geração de texto por LLMs, esse tipo de análise ganha ainda mais relevância. Afinal, não basta gerar texto, é preciso garantir que ele seja adequado ao público-alvo. Métricas de legibilidade ajudam justamente a entender essa adequação entre o que se espera e o que foi alcançado.

Por fim, no contexto de sistemas conversacionais, a legibilidade pode atuar como uma camada adicional de validação. É comum instruirmos modelos a responder com uma “linguagem acessível”, mas como verificar se isso realmente foi cumprido? Os índices de legibilidade oferecem uma forma simples e objetiva de mensurar esse aspecto, funcionando como um critério complementar de avaliação do output.

REFERÊNCIAS

[1] https://legibilidade.com/

[2] Gleice Carvalho de Lima Moreno, Marco P. M. de Souza, Nelson Hein, Adriana Kroenke Hein.ALT: um software para análise de legibilidade de textos em Língua Portuguesa

[3] R. Flesch, “A new readability yardstick”. J. Appl. Psychol 32(3), 221–233 (1948).

LEGIBILIDADE — Como saber se meu texto é muito complexo? was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

Nesse artigo serão abordados alguns conceitos mais complexos e dois dos mais interessantes para utilização através do LangChain, os agentes e RAG. Essas ferramentas possibilitam o desenvolvimento de aplicações utilizando LLMs que são mais dinâmicas e personalizáveis, podendo especializar as respostas para certo tópico e utilizar de um LLM para gerenciar as ações a serem realizadas pela aplicação.

Agentes

Podemos pensar nos agentes como um orquestrador que permite criar sistemas inteligentes capazes de tomar decisões dinâmicas e executar tarefas de forma autônoma. Essas tarefas são suportadas através de funções que os agentes utilizam para realizar suas ações e obter respostas.

Diferente das cadeias sequenciais, conceito abordado no artigo anterior, em que as ordens das ações são pré-estabelecidas no código, os agentes utilizam de um LLM que é capaz de escolher quais ferramentas utilizar e em qual ordem dependendo do contexto da conversa, de forma autônoma.

Os agentes possuem três componentes principais: um modelo de linguagem (LLM), que atua como o cérebro do agente para escolher as ferramentas a serem usadas; ferramentas (tools), funções personalizadas que podem incluir APIs, bancos de dados ou realizar qualquer outro tipo de tarefa como o próprio RAG, que será explicado em breve; e um executor (agent executor), que gerencia a interação entre esses componentes. O agente recebe uma solicitação, analisa quais ferramentas são necessárias para respondê-la e decide, dinamicamente, como resolver a tarefa.

Existem diversos tipos de agentes que podem ser utilizados em diferentes contextos, mas para entender a ideia central desse conceito, iremos explorar o Agente ReAct.

Agente ReAct

Os agentes ReAct (Reason + Action) funcionam a partir de pensamento e ação. Após ser acionado, nosso agente irá (1) pensar na tarefa e em qual das ferramentas que ele possuí é a adequada. (2) Após isso, realiza a ação através da ferramenta escolhida, e por fim, (3) observa a saída da ferramenta gerando a resposta para o usuário.

Então vamos pensar em um agente ReAct que irá responder questões de matemática e literatura. Para criarmos nosso agente especializado, precisaremos de pelo menos duas ferramentas que o nosso agente possa acionar para realizar suas ações, uma ferramenta específica para questões de matemática que chamaremos de “math_tool” e outra para questões de literatura que chamaremos de “literature_tool”. Não entrarei no detalhe de cada uma dessas funções em si (math_function e literature_function), mas vamos supor que elas acessem uma API de seus respectivos domínios (matemática e literatura) oferecendo conteúdo para uma resposta mais correta para cada um dos temas.

No exemplo utilizaremos o agente ZERO_SHOT_REACT_DESCRIPTION que segue a abordagem ReAct. Ele é uma versão específica dentro do LangChain, que não precisa de exemplos e se baseia apenas na descrição (description) das ferramentas disponíveis para escolher com qual ferramenta irá realizar a ação.

math_tool = Tool(
 name="Math tool",
 func=math_function,
 description="Responde questões sobre matemática como problemas de adição, 
subtração, multiplicação e devisão."
)

literature_tool = Tool(
 name="Literature tool",
 func=literature_function,
 description="Responde questões sobre literatura como análise de obras, 
autores e citações."
)
agent = initialize_agent(
 tools=[math_tool, literature_tool],
 llm=llm,
 agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
)

Por exemplo, quando o agente receber uma chamada com o prompt “Quanto é 1 + 1?”, ele irá (1) iniciar o processo, analisando essa questão e identificando que é relacionada ao escopo de matemática. Após isso, então através das descrições da função, irá identificar que deve (2) chamar a nossa ferramenta “math_tool” para realizar a ação, por ser a descrição que mais se enquadra na questão do usuário. Por fim, (3) com a saída gerada pela ferramenta irá retornar uma resposta para o usuário: “A soma de 1+1 é igual a 2.”. Observe a seguir como o agente irá agir com essa entrada.

agent.run("Quanto é 1 + 1?")

Observe que ele precisou chamar apenas a ferramenta específica para questões de matemática sem nenhuma ordem pré-definida. Foi o LLM que identificou que essa era uma questão deste escopo.

Os agentes são muito úteis para criar aplicações de escopos e ações específicas, sendo que, a qualidade de um agente está diretamente ligada à qualidade de suas ferramentas. Quanto melhor a qualidade das ferramentas para realizar as ações, melhores serão as respostas dos agentes.

RAG com LangChain

RAG (Retrieval Augmented Generation) é uma técnica para aprimorar o LLM, incorporando documentos mais atualizados do que aqueles utilizados em seu treinamento ou restringindo o escopo para torná-lo especialista em um determinado tópico.

Podemos dividir em três passos principais a implementação de RAG com LangChain:

1. Carregar os documentos: primeiro carregamos os documentos que serão utilizados para fornecer novos dados ao LLM. O LangChain já nos fornece algumas classes como PyPDFLoader, CSVLoad, UnstructeredHTMLLoader que possibilitam carregar arquivos .pdf, .csv e .html, respectivamente.

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader(
    "rag_example.pdf",
)
data = loader.load()

2. Divisão de dados: após carregarmos os dados, é necessário dividi-los em partes menores para que respeitem o tamanho da janela de contexto do LLM. É interessante manter uma sobreposição de contexto entre as divisões, por exemplo, o documento 1 e documento 2 possuirão uma parte em comum do documento, permitindo a retenção do contexto (nas classes o parâmetro chunk_overlap representa essa sobreposição). O LangChain nos permite utilizar alguns tipos de divisão de dados, entre eles, temos:

CharaterTextSplitter: este método visa satisfazer primeiro o caractere separador e depois o chunk_size e o chunk_overlap. Por dar prioridade ao separador, pode ser que esse método não respeite os limites do chunk_size e do chunk_overlap.

from langchain_text_splitters import CharacterTextSplitter

text_splitter = CharacterTextSplitter(
    separator=".",
    chunk_size=1000,
    chunk_overlap=200,
)
docs = text_splitter.split_text(data)

RecursiveCharacterTextSplitter: utiliza uma lista de separadores possíveis para fazer a divisão, e, recursivamente observa se as divisões podem ser unificadas, buscando sempre satisfazer o limite do chunk_size. Dessa forma, esse método resulta em uma divisão mais equilibrada e otimizada do que a citada anteriormente.

from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    separators=[".","\n", " "],
    chunk_size=1000,
    chunk_overlap=200,
)
docs = text_splitter.split_documents(data)

3. Armazenamento e recuperação: com a utilização de Embeddings, cada documento de texto será transformado em vetor, para que assim possamos extrair o seu valor semântico e posteriormente recuperarmos o documento que mais se assemelha com a requisição do usuário. Dessa forma, após a transformação, os documentos serão armazenados em um banco de dados vetorial. Segue um exemplo de utilização com o Chroma:

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

"""carregamos o Embedding que será utilizado"""
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

"""transformamos os documentos e armazenamos vetores gerados 
utilizando Embedding"""
vector_store = Chroma(
    docs,
    embedding_function=embeddings,
    persist_directory="path_to_save",
)

"""recuperamos os dados de três documentos a partir de similaridade, ou seja,
os que mais se aproximam da pergunta do usuário"""
retriever = vectorstore.as_retriever(
  search_type="similarity",
  search_kwargs={"k": 3}
)

"""criamos uma cadeia sequencial que possibilita passarmos os documentos
recuperados pelo retriever como uma diretriz"""
rag_chain = ({"guidelines": retriever}
             | prompt_template
             | llm)

"""executamos a cadeia sequencial com o RAG"""
rag_chain.invoke(question)

Conclusão

Neste artigo e no anterior “Como criar aplicações com LLM: Introdução ao LangChain” discutimos sobre diferentes classes e funções disponíveis a partir do LangChain. Todas as ferramentas citadas podem ser utilizadas de forma integrada para criar uma aplicação com LLMs.

Começamos definindo qual o objetivo da nossa aplicação, e, após essa definição, analisamos qual LLM suprirá a complexidade envolvida. Então, criamos um agente e definimos as ferramentas (tools) que são necessárias para aplicação, como por exemplo, tools que utilizam de RAG para escopos específicos, e também, criamos os templates que serão utilizados para a aplicação e ferramentas. Dessa forma é possível desenvolver uma aplicação na qual se utiliza grandes modelos de linguagem com uma menor complexidade.

O LangChain vem se provando um ótimo framework para o desenvolvimento de aplicações baseadas em NLP e vale a atenção para os novos recursos que são constantemente adicionados à biblioteca.

Como criar aplicações com LLM: Agentes e RAG com LangChain was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

O uso de Modelos de Linguagem de Grande Escala (LLMs) ganhou espaço em diversas aplicações e com isso se tornou imprescindível o desenvolvimento de ferramentas que auxiliem na utilização dos mesmos.

O LangChain é uma biblioteca open-source que facilita a criação de aplicações baseadas em LLMs. Além de possibilitar acesso a dados externos e maior escalabilidade tornando as aplicações mais dinâmicas, oferece ferramentas modulares para construir chatbots, agentes autônomos e sistemas avançados de perguntas e respostas através de classes e funções prontas, proporcionando um ambiente estruturado e eficiente para explorar o potencial dos LLMs e criar soluções inovadoras com menor esforço.

Por ser uma ferramenta open-source e em contínuo desenvolvimento, vale ressaltar certa atenção para a compatibilidade dos exemplos a seguir, onde foi utilizada a versão 0.3.13 da biblioteca, podendo haver diferenças em outras versões, mas os conceitos explicados permanecerão os mesmos.

Carregando modelos

Vamos iniciar com o primeiro passo necessário para criar uma aplicação baseada em LLM, carregá-lo. É possível carregar diversos LLMs para utilização a partir desse framework, como, por exemplo, modelos presentes nas APIs do HuggingFace e da OpenAI. O LangChain possui classes que permitem interagir de maneira fácil com essas duas APIs para carregar os seus modelos como descrito a seguir.

Criando seu token e carregando um modelo com a API do HuggingFace:

1. Entre na sua conta do HuggingFace
2. Acesses os tokens em configurações: https://huggingface.co/settings/tokens
3. Selecione New Token para criá-la

from langchain_huggingface import HuggingFaceEndPoint

llm = HuggingFaceEndpoint(
  repo_id='titiuae/falcon-7b-instruct',
  huggingfacehub_api_token=your_api_token)

Criando seu token e carregando um modelo com a API da OpenAI:

1. Entre na sua conta da OpenAI
2. Acesse o link: https://platform.openai.com/api-keys
3. Selecione Create New Secret Key para criá-la

from langchain_openai import OpenAI

llm = OpenAI(
  repo_id='gpt-3.5-turbo-instruct',
  api_key=your_api_token)

Existem outras formas de carregar LLMs utilizando o LangChain, como utilizar o Ollama através do langchain_ollama para rodar o modelo localmente.

1. Instale o Ollama e o pacote necessário: pip install langchain_ollama
2. Baixe localmente um modelo através do comando ollama pull como, por exemplo: ollama pull llama2
3. Carregue o modelo em seu código python:

from langchain_ollama import OllamaLLM

llm = OllamaLLM(model="llama2")

Prompts

Após selecionarmos e carregarmos o modelo com que iremos trabalhar, exploraremos a criação de prompts. O LangChain possui diferentes tipos de templates e cada um com sua especificidade de aplicação, aqui serão citados apenas três deles.

1. PromptTemplates: este template é o mais comum, utilizado para criar um prompt mais simples e de string única, no qual podemos passar valores como parâmetros.

from langchain_core.prompts import PromptTemplate

prompt_template = PromptTemplate.from_template("Tell me a joke about {topic}")
prompt_template.invoke({"topic": "cats"})

2. ChatPromptTemplates: este template é ideal para aplicações de ChatBot ou Perguntas e Respostas (Q&A), pois nos possibilita passar um histórico de mensagens como prompt. O LLM levará em conta o histórico passado para gerar sua resposta. Esse histórico possui três tipos diferentes de mensagens:

a. AIMessage: utilizado para indicar as respostas geradas pelo LLM.

b. HumanMessage: utilizado para indicar entradas do usuário.

c. System Message: utilizado para alterar o comportamento do modelo, por exemplo, pedir para que ele seja mais “educado” na resposta.

from langchain_core.prompts import ChatPromptTemplate

prompt_template = ChatPromptTemplate([
    ("system", "You are a helpful assistant"),
    ("human", "Tell me a joke about cats"),
    ("ai", "Who delivers Christmas presents to cats? Santa Claws."),
    ("human", "Now tell me about {topic}")
])
prompt_template.invoke({"topic": "dogs"})

3. MessagePlaceHolder: esse prompt possibilita inserir uma quantidade específica de mensagens em certa parte do nosso prompt, tornando-o mais flexível se assim for necessário, como se fosse um ChatPromptTemplates dinâmico. No exemplo abaixo nós estamos inserindo uma lista com duas mensagens onde declaramos MessagesPlaceholder(“msgs”), ou seja, nosso prompt nesse caso teria três instruções e poderíamos inserir mais ou menos conforme a necessidade.

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage

prompt_template = ChatPromptTemplate([
    ("system", "You are a helpful assistant"),
    MessagesPlaceholder("msgs")
])
prompt_template.invoke({"msgs": [HumanMessage(content="hi!"), 
                                HumanMessage(content="how are you?")]})

Histórico de conversação

Seguindo a ideia dos prompts específicos para ChatBot, agora abordaremos uma das principais ferramentas desse framework: o histórico de conversação.

O LangChain possui classes que nos permitem armazenar o contexto de conversa com o LLM, possibilitando respostas mais robustas com o uso prolongado da aplicação. A seguir serão apresentadas três das principais possibilidades para armazenar o histórico de conversação.

1. ChatMessageHistory: salva todas as mensagens do histórico. Sempre que é adicionado uma nova mensagem, as anteriores continuam armazenadas e serão consideradas para a resposta seguinte do LLM. O histórico é perdido quando o sistema é reiniciado ou a aplicação é fechada.

2. ConversationBufferMemory: funciona como um buffer, armazenando o histórico de um número específico de mensagens e, conforme novas mensagens chegam e ultrapassam o limite do buffer, as anteriores são perdidas. Para isso é utilizado um tipo especial de conversação por cadeia (ConversationChain) que permite que o modelo receba essa memória para gerar sua resposta. Este método é indicado para aplicações com conversas curtas.

3. ConversationSummaryMemory: sumariza a conversa mantendo um contexto resumido ao longo do uso do LLM. É passado um LLM (summarizer_llm) como parâmetro para ConversationSummaryMemory, e esse LLM será o responsável por realizar a sumarização do histórico de conversação, mantendo o contexto. Este método é indicado para aplicações com conversas longas.

Cadeias sequenciais

Agora falaremos de uma ferramenta muito útil do LangChain e que abrirá portas também para a continuação desse artigo, as cadeias sequenciais. Existem alguns problemas que são resolvidos e executados apenas de forma sequencial, onde a ação seguinte depende exclusivamente da resposta de uma ação anterior.

As cadeias sequenciais são estruturas que permitem encadear múltiplos passos em uma única operação. As cadeias permitem criar fluxos de execução onde a saída de um passo pode ser usada como entrada para o próximo. Isso possibilita combinar diferentes ferramentas em uma única operação como, por exemplo, cada ação (chamada de LLM) precisa ter seu prompt para realizar a consulta esperada ao LLM e, em geral, a resposta do LLM precisa ser convertida em uma estrutura aceita pelo seu sistema.

Abaixo utilizaremos de um exemplo de aplicação onde o usuário pede um itinerário de viagem, mas para criar esse itinerário, o LLM precisa listar as atividades mais interessantes daquele local, ou seja, a ação de criar um itinerário é dependente de uma ação anterior que é listar as atividades. Dessa forma, se faz necessário a utilização das cadeias sequencias. Note também que, para o exemplo abaixo, abordaremos todos os temas citados anteriormente (exceto o histórico de conversação).

Para criar uma cadeia sequencial seguimos alguns passos utilizando LCEL (LangChain Expression Language). Observe que o “|” (pipe) é utilizado para separar cada um dos passos dentro da cadeia. Os passos acontecem de forma sequencial, seguindo os “|”:

1. Criamos os prompts para cada uma das chamadas que acontecerão, sendo o primeiro prompt para listar as atividades e o segundo para criar o itinerário;

2. Iniciamos a criação da cadeia de sequência criando um dicionário onde result_from_first_template será o parâmetro que o segundo prompt receberá como entrada e o valor será o resultado da chamada do LLM utilizando o prompt first_template e convertendo a saída do LLM para string (StrOutputParse);

3. Após obtermos a primeira chamada, seguimos com a cadeia chamando o segundo prompt, seguido pela chamada do LLM e convertendo a saída para string.

Dessa forma, é possível encadearmos diversas chamadas de LLM em sequência quando uma for dependente da outra, utilizando apenas criação de prompts junto ao LCEL.

Conclusão

Passamos por alguns conceitos mais básicos como carregar modelos, criar prompts, até chegarmos a alguns mais complexos como histórico de conversação e cadeias sequenciais. Veja como esses tópicos podem ser utilizados em conjunto de uma aplicação, como um ChatBot, que depende de uma sequencia de ações fixa para responder o usuário, e o LangChain nos possibilita utilizar tudo isso a partir de um único framework.

Há muita coisa que não cabe apenas neste artigo, por isso, o principal objetivo é o encorajamento para aprofundar sobre o assunto. Este é um framework muito recente, tornando-se necessárias constantes atualizações das novas funções e classes que a comunidade incorpora a ele.

No próximo artigo “Como criar aplicações com LLM: Agentes e RAG com LangChain” discutiremos sobre duas ferramentas que são um pouco mais complexas do que as tratadas nesse artigo e que também as complementam.

Como criar aplicações com LLM: Introdução ao LangChain was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

Uma breve Introdução

A inteligência artificial generativa está transformando a maneira de criar conteúdo na internet com sua habilidade de criar conteúdo originais e customizados. Das escritas persuasivas à geração de imagens realísticas, as aplicações dessa tecnologia são amplas e promissoras. Os grandes players (Amazon, Google e Microsoft), não ficaram de fora desse boom da IA.

Nesse artigo, vamos fazer uma breve comparação dos serviços do Amazon, Google e Microsoft voltados para a IA.

Os fundamentos da IA generativa e seu impacto

Para começar a falar precisamos primeiro entender o que é IA generativa.

A Inteligência Artificial Generativa (IAG) é um ramo da inteligência artificial que permite a criação de novos conteúdos, como textos, imagens, músicas e códigos, a partir de dados existentes. Ela funciona treinando modelos de computador em grandes conjuntos de dados para identificar padrões e relações. Uma vez treinados, esses modelos podem gerar novos conteúdos que são semelhantes aos dados originais, mas igualmente originais e criativos. A IAG tem aplicações em diversas áreas, desde a geração de arte e design até a criação de conteúdo para marketing e a produção de software. No entanto, é importante ressaltar que a qualidade e a relevância dos conteúdos gerados dependem da qualidade dos dados de treinamento e da arquitetura do modelo.

Em resumo, o IAG é uma tecnologia que permite a criação de novos conteúdos de forma autônoma, abrindo um leque de possibilidades para a criatividade e a inovação em diversos ramos no mercado.

O usuário final, ao interagir com produtos e serviços de grandes empresas como Amazon, Microsoft e Google, está utilizando inteligência artificial de forma cada vez mais integrada ao seu dia a dia. Desde as recomendações personalizadas de produtos em plataformas de e-commerce até a tradução instantânea de textos em aplicativos de mensagens, a IA está presente em diversas ferramentas para facilita a vida do usuário.

A IA está transformando a relação entre empresas e consumidores, tornando as interações mais personalizadas e eficientes, mas é fundamental que essa tecnologia seja desenvolvida e utilizada de forma responsável e consciente.

Amazon Bedrock

O Amazon Bedrock se trata de um serviço que oferece várias opções de modelos de base (FM) de alta performance das principais empresas de IA dentro da Amazon Web Services, que oferecem um conjunto de modelos para o auxílio no desenvolvimento e implantar soluções de IA pôr um custo acessível. Estes modelos podem ser usados para tarefas simples a mais complexas como geração de texto, tradução, pesquisa, geração de imagens e geração de código.

Segurança, privacidade e práticas responsáveis ​​de IA são princípios fundamentais para a Bedrock.

Alguns pontos positivos e negativos sobre essa tecnologia irei aborda a seguir.

Pontos Positivos

• Variedade de modelos: O Amazon Bedrock oferece acesso a uma ampla gama de modelos de base de empresas líderes em IA permitindo que os usuários escolham o mais adequado para suas necessidades específicas.
• Escalabilidade: O serviço foi projetado para ajudar você a construir e dimensionar rapidamente aplicativos de IA generativa, facilitando o manuseio de projetos de grande escala.
• Segurança e privacidade: O Amazon Bedrock garante que seus dados permaneçam seguros e privados, o que é crucial para muitas empresas
• Suporte da Amazon: A plataforma se beneficia de uma infraestrutura robusta e investimento contínuo em tecnologia de IA.

Pontos Negativos

• Potencial monopolização: há preocupações de que o domínio da Amazon no espaço de IA possa limitar as oportunidades para empresas menores
• Restrições de acesso: os usuários precisam solicitar acesso a determinados modelos, o que pode atrasar o processo de desenvolvimento
• Preocupações com privacidade de dados: apesar de suas medidas de segurança, há preocupações gerais sobre privacidade de dados em aplicativos de IA.
• Dificuldade de Detectar Vieses: Detectar e mitigar vieses em modelos de linguagem de grande porte é um desafio complexo, exigindo técnicas avançadas de análise de dados. Essas abordagens são a análise de sensibilidade, técnicas de explicabilidade, detecção de anomalias, métodos estatísticos, aprendizado de máquina e análise de texto.

Google Vertex AI

O Google Vertex IA é uma plataforma de machine learning (ML) que permite treinar e implantar modelos de ML e aplicativos de IA. A Vertex AI combina fluxos de trabalho de engenharia de ML, dados e ciência de dados, permitindo que suas equipes colaborem usando um conjunto de ferramentas comum e escalonem seus aplicativos usando os benefícios do Google Cloud.

Incluindo mais de 150 modelos de fundação tipo o PaLM 2, Gemini 1.5 Pro e o Gemini 1.5 Flash. Tendo acesso ao Vertex Ai Studio, Agente Builder e as ferramentas de MLOps personalizados para os cientistas de dados gerenciarem os projetos de ML.

Como nem tudo é perfeito, vou citar alguns pontos positivos e negativos sobre o Google Vertex AI.

Pontos Positivos

• Plataforma unificada: Vertex AI oferece uma plataforma única para construir, implantar e escalar modelos de aprendizado de máquina, simplificando o fluxo de trabalho.
• Escalabilidade: Ele pode lidar com tarefas de aprendizado de máquina em grande escala, sendo adequado para empresas com necessidades significativas de dados e computação.
• Capacidades AutoML: O Vertex AI inclui AutoML, permitindo que os usuários criem modelos de alta qualidade com esforço mínimo, mesmo que tenham conhecimento limitado em aprendizado de máquina. O AutoML permite treinar dados tabulares, de imagem, de texto ou de vídeo sem escrever códigos ou preparar divisões de dados. Vou deixar para explicar melhor em um próximo artigo.
• Modelos Pré-construídos: A plataforma oferece modelos pré-construídos (PaLM 2, Gemini 1.5 Pro e o Gemini 1.5 Flash) para tarefas comuns (Extrair, resumir e classificar dados), economizando tempo e recursos.
• Integração com Google Cloud: Sendo parte do ecossistema Google Cloud, ele se integra perfeitamente com outros serviços do Google, aumentando sua funcionalidade e facilidade de uso.

Pontos Negativos

• Complexidade para Iniciantes: Embora poderoso, o Vertex AI pode ser complexo para usuários sem um forte conhecimento em aprendizado de máquina, exigindo uma curva de aprendizado acentuada.
• Custo: O preço pode escalonar rapidamente, especialmente para casos de uso extensivos, o que pode ser uma preocupação para empresas menores.
• Personalização Limitada: Alguns usuários notaram que, embora o AutoML seja conveniente, ele oferece opções limitadas de personalização em comparação com a construção de modelos do zero.

Azure OpenAI

O Azure OpenAI Service é um serviço totalmente gerenciado que permite aos desenvolvedores integrar modelos OpenAI em seus aplicativos. Ele fornece modelos avançados de IA de linguagem, incluindo GPT-4, GPT-3, Codex, DALL-E e modelos de conversão de texto em fala, com a promessa empresarial e de segurança do Azure.

Esses modelos podem ser facilmente adaptados à sua tarefa específica, incluindo, entre outros, geração de conteúdo, resumo, compreensão de imagens, pesquisa semântica e linguagem natural para tradução de código. Os usuários podem acessar o serviço por meio de APIs REST, Python SDK ou a interface baseada na Web no Azure OpenAI Studio.

O Azure enfatiza a integração permitindo um desenvolvimento eficiente dentro do ecossistema Microsoft.

Assim como o Amazon Bedrock e o Google Vertex AI, o Azure OpenAI também apresenta pontos positivos e negativos.

Pontos Positivos

• Capacidades Avançadas de IA: O Azure OpenAI oferece acesso a modelos generativos poderosos, permitindo que as empresas criem aplicações de IA sofisticadas para diversos casos de uso, como processamento de linguagem natural, automação de atendimento ao cliente e geração de conteúdo.
• Integração com o Ecossistema Azure: Ele se integra perfeitamente com outros serviços do Azure, oferecendo recursos robustos de segurança, escalabilidade e conformidade, essenciais para aplicações empresariais.
• Inovação e Eficiência: O serviço ajuda as empresas a otimizar processos, melhorar a experiência do cliente e impulsionar a inovação, levando a uma maior eficiência e competitividade.
• Suporte e Recursos: A Microsoft fornece documentação extensa, suporte e recursos para ajudar os desenvolvedores a construir e implantar soluções de IA de forma eficaz.

Pontos Negativos

• Custo: Utilizar o Azure OpenAI pode ser caro, especialmente para pequenas empresas ou startups, devido aos altos recursos computacionais necessários para executar modelos avançados de IA. Se o cliente opta pelo modelo GPT-4o Global Deployment irá pagar no input $5, no output $15 e $260 na reserva mensal pro PTU (Provisioned Throughput Units ou unidades de produção provisionadas)
• Complexidade: Implementar e gerenciar soluções de IA com o Azure OpenAI pode ser complexo, exigindo conhecimento especializado em IA e serviços em nuvem.
• Lista de Espera: Devido à alta demanda, o acesso aos modelos mais avançados do Azure OpenAI pode exigir inscrição em uma lista de espera. A Microsoft precisa garantir que tenha capacidade suficiente para atender a todos os usuários.
• Potencial para Conteúdo Nocivo: Sem um design cuidadoso e mitigações, os modelos generativos têm o potencial de produzir conteúdo incorreto ou prejudicial, o que exige monitoramento e controle rigorosos.

Qual das 3 plataformas escolher?

A seguir temos uma análise abrangente de como essas plataformas se comparam em aspectos importantes:

Por exemplo, a feature customização são limitadas no Amazon Bedrock e no Microsoft Azure. Já o Google Vertex AI saí na frente com modelos customizados.

Casos de usos práticos

Irei citar dois exemplos de uso com a plataforma Amazon Bedrock. Alguns termos que serão utilizados nos casos de uso a seguir.

• API Gateway: O Amazon API Gateway é um serviço da AWS para criação, publicação, manutenção, monitoramento e proteção de APIs Rest. APIs agem como a “Porta de entrada” para aplicativos acessarem dados, lógica de negócios ou funcionalidade de seus serviços
• Lambda Function: O AWS Lambda é um serviço de computação sem servidor e orientado por eventos que permite executar códigos para praticamente qualquer tipo de aplicação ou serviço de back-end sem provisionar ou gerenciar servidores, ou seja, toda a infraestrutura como servidor, network e OS já são de responsabilidade do AWS Lambda Function para você focar apenas em escrever o código da aplicação.
• Bedrock: O Amazon Bedrock é um serviço totalmente gerenciado que oferece várias opções de modelos de base (FMs) de alta performance das principais empresas de IA.
• Cohere: Modelo que foi previamente treinado no AWS.
• Stability.AI: Outro modelo que foi previamente treinado no AWS. Temos muitos outros modelos como AI21 Labs, Anthropic, Cohere, Meta, Stability AI e Amazon
• S3 Bucket: O amazon S3 (Simple Storage Service) é um serviço de armazenamento de objetos escalável e altamente disponível oferecido pela Amazon Web Services (AWS).

1. Caso de uso: Seguradora.

Um bom exemplo é seguradoras de veículos ou empresas que alugam equipamentos e/ou maquinários. Melhorando o fluxo de trabalho e garantindo a análise correta do ativo da empresa.

Imagine a seguinte situação: Um cliente que tenha sofrido um acidente com seu carro alugado ou próprio envia as imagens do carro para a seguradora e um técnico está demorando para fazer a análise e liberar o seguro. O cliente que tem como único meio de trabalho o carro, ficará sem receber.

Com uma solução de um sistema integrado com à IA, é possível gerar uma prévia utilizando o Amazon Bedrock. Isso permite determinar se houve uma perda total do veículo antes de encaminhá-lo a um especialista da seguradora, agilizando o processo interno.

O Usuário tem um sistema que pode enviar uma foto que será recebida pelo API Gateway então essa ferramenta serviria como um “Porteiro” deixando entrar apenas os credenciados para então enviar para uma função Lambda, aqui será a execução do código e toda regra de negócio tratando qualquer erro possível de acontecer nessa comunicação.

Se a requisição for bem-sucedida o próximo passo será enviar para o Amazon Bedrock com o prompt e demais parâmetros obrigatórios tipo o modelo que eu quero utilizar, nesse caso do exemplo é o Cohere. Por fim, o modelo treinado gera o prompt, ou seja, com base na foto enviada, sendo gerado os resultados esperados como perda total ou parcial.

2. Caso de uso: Publicidade.

Outro caso de uso seria uma empresa de marketing que solicitou para um funcionário gerar um pôster de um filme que será lançado ou um produto novo. Antigamente, era preciso um tempo e inputs para esse funcionário gerar um pôster criativo. Com as novas tecnologias feita com IA, podemos solicitar da ferramenta para gerar um pôster com algumas linhas de prompts em poucas horas.

A maior parte do caso de uso funcionara parecido com o caso de uso da seguradora. O usuário tem um sistema que solicita para a aplicação gerar um pôster com base em alguns prompts de entrada. A API Gateway servirá como o porteiro, depois chegará na função lambda onde será executado algum tipo de código em uma linguagem escolhida.

Ao passar por essa etapa, vai chegar no Amazon Bedrock, ele irá escolher o modelo que definimos na arquitetura, o modelo é executado, que nesse caso é o Stability.ai, e devolve o output com a solicitação do usuário.

O Amazon Bedrock envia para o S3 Bucket fazer o upload no sistema de armazenamento de objetos. O S3 Bucket retornará apenas a URL para o meu usuário final depois de salvar a url.

Conclusão

Plataformas amigáveis para usuários de IA generativa devem se tornar cada vez mais comuns, tornando a tecnologia acessível a mais pessoas. É importante que as empresas entendam os pontos fortes e fracos de cada plataforma para utilizar efetivamente a IA generativa e se manterem competitivas no mercado. Ao avaliar necessidades e prioridades específicas, as empresas podem escolher a melhor plataforma para aproveitar todo o potencial da IA generativa e impulsionar a inovação.

Referências:

LECHNER, A. Amazon Bedrock: A nova Era da IA generativa. 20 maio 2024. Disponível em: https://www.dio.me Acesso em: 25 jul. 2024

‌Google, Exemplos de IA generativa. Disponível em: Exemplos de IA generativa | Google Cloud. Acesso em: 02 set 2024.

AWS, O que é IA generativa? Disponível em: O que é IA generativa? — Explicação da inteligência artificial generativa Acesso em: 05 set 2024

AWS, Crie aplicações de IA generativa com modelos de base — Amazon Bedrock . Disponível em: Amazon Bedrock. Acesso em: 05 set 2024

Google, Introdução à Vertex AI. Disponível em: Introdução à Vertex AI Acesso em:02 out 2024

Microsoft, What is Azure OpenAI Service? Disponível em: What is Azure OpenAu Services Acesso em: 02 out 2024

Microsoft, Azure OpenAI service documentation. Disponível em: Azure OpenAI Service documentation — Quickstarts, Tutorials, API Reference — Azure AI services | Microsoft Learn Acesso em: 02 out 2024

Kaushik, V. Amazon Bedrock vs Google Vertex AI vs Microsoft Azure Cognitive Services. Disponível em: Amazon Bedrock vs. Google Vertex AI vs. Microsoft Azure Cognitive Services: A Battle for Generative AI Supremacy | by Vikas Kaushik | Medium Acesso em: 02 out 2024

Papel da Amazon, Google e Microsoft na era da IA Generativa was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

A dimensionalidade é um problema recorrente para aplicação de redes neurais e por conta disso existem diversas técnicas possíveis para resolver esse problema.

No artigo anterior, quantização foi o método abordado para realizar a compressão de redes neurais. Neste, será abordado um tema complementar ao assunto, onde serão introduzidos novos métodos para realizar a compressão de modelos, principalmente o método de “poda” (pruning) e também um método híbrido, onde é utilizado tanto a poda quanto o método de quantização. Os métodos “clustering” e “knowledge distillation” também serão mencionados.

Poda (Pruning)

O método de poda busca os mesmos objetivos comentados para a quantização, ambos visam adaptar o modelo para utilizá-lo em aparelhos com menor recurso computacional sendo necessário diminuir a complexidade da rede neural utilizada.

Diferente da quantização (imagem acima), como visto anteriormente, em que a complexidade é reduzida alterando o tipo de dado utilizado nos pesos e saídas da rede (alteração de float32 para int32, por exemplo), no método de poda isso é realizado através da “remoção” de pesos da rede, o tipo de dado utilizado se mantém o mesmo. Essa remoção pode acontecer de duas formas e, por isso, existem dois diferentes métodos de poda: o estruturado e o não estruturado. A grande diferença entre os dois métodos se dá por conta da forma que os pesos são “removidos”, buscando a diminuição de complexidade da rede.

Antes de explicar sobre cada uma das duas técnicas de podas existentes, será apresentado os critérios para realizar poda e seu conceito principal.

Critérios de poda

Tendo em vista que o objetivo desse método é remover os pesos da rede neural buscando uma menor complexidade e pouca perda de acurácia para o modelo, precisa ser definido qual critério será utilizado para realizar a poda dos pesos. Existem três principais critérios que podem ser aplicados:

Magnitude do peso (weight magnitude): nesse critério realiza-se a poda baseado no valor absoluto dos pesos, indica-se um valor de corte (threshold) que será a magnitude mínima permitida para um peso, todos os pesos que possuírem magnitude menor a esse threshold sofrem o processo de poda. Após a aplicação do método utilizando o critério de magnitude, costuma ser recomendado a aplicação de uma normalização nos demais pesos, fazendo com que os mesmos se aproximem de zero.

Magnitude do gradient (gradient magnitude): este critério leva em consideração o gradiente durante o processo de treinamento da rede neural, a cada época ou mini batch, o valor do gradiente é observado e determina quais pesos sofrerão da poda.

Poda local ou global: este critério realiza a poda em uma porcentagem fixa da rede neural e pode ser aplicado de duas formas, local ou global.
Da maneira local a porcentagem será aplicada igualmente para cada layer da rede, por exemplo, uma porcentagem de 50% significa que cada layer terá metade dos seus pesos cortados. Já o método global não leva em consideração cada camada, a poda será realizada em 50% dos pesos de uma forma geral, as camadas sofrerão diferentes quantias de poda.

Agora que conhecemos os possíveis critérios para realização da poda, falaremos sobre os dois tipos de poda: não-estruturada e estruturada.

Poda Não-Estruturada

Como dito anteriormente, a grande diferença entre os dois métodos de poda estão na forma como os pesos são removidos. Na poda não-estruturada os pesos não são removidos da rede de fato, na verdade eles são substituídos por zero. Dessa forma a arquitetura da rede neural não sofre alterações, o número de camadas e neurônios permanecerá o mesmo do modelo original, o que será alterado são apenas os valores dos pesos selecionados pelo critério de poda.

Essa abordagem é mais eficaz para redução de tamanho do modelo e tempo de inferência, mas não muito eficiente para desempenho e custo da rede neural.

Poda Estruturada

Diferente do método anterior, a poda estruturada realiza alterações diretas na arquitetura, ela não altera o valor dos pesos para zero, mas os remove, retirando alguns neurônios ou até mesmo camadas inteiras da rede neural.

Este método é mais invasivo do que o anterior e, por conta disso, precisa ter mais cautela ao ser aplicado, pois ele pode gerar uma perda de acurácia maior do que a esperada. Além disso, é necessário prestar atenção em como o método está alterando a arquitetura da rede: dependendo da camada que é podada, isso pode resultar em saídas não esperadas pela rede, gerando erros de execução.

Poda e quantização

Como explicado acima, o método de poda é mais uma forma de reduzir a dimensionalidade do modelo, mas utilizando de estratégias e critérios como a relevância e magnitude de certos parâmetros para “removê-los”.

Mas mesmo após aplicação da técnica de poda e com o conhecimento obtido no artigo sobre quantização, vemos que existe margem para melhorar a compressão do modelo. Uma vez que a poda apenas “remove” os parâmetro que seu critério não julga relevante, os demais parâmetros permanecem na rede neural em seu estado natural, ou seja, em ponto flutuante.

Utilizando as duas técnicas em conjunto é possível obter uma compressão do modelo ainda melhor, chegando a reduzir o seu tamanho em até 20x. Sobre a perda de acurácia que é sempre a maior preocupação, é importante tomar cuidado principalmente na etapa de poda, mas em geral a perda de acurácia através da aplicação das duas técnicas em conjunto é muito similar a perda quando é aplicada apenas uma das técnicas.

Para aplicação de ambas as técnicas em conjunto é muito simples, basta seguir o passo a passo de ambas, primeiro realizando a poda de sua rede neural, após isso, aplicar o algoritmo de quantização na sua rede e pronto, resultará em uma rede neural com menor tamanho e latência, além de uma acurácia muito similar ao modelo original.

A seguir está um código onde é possível utilizar o método de poda e quantização juntos, mais detalhes podem ser encontrados no site do tensorflow:

import tensorflow_model_optimization as tfmot

prune_low_magnitude = tfmot.sparsity.keras.prune_low_magnitude

# Calcula o "end step" para finalizar a poda após 2 "epochs".
batch_size = 128
epochs = 2
validation_split = 0.1 # 10% of training set will be used for validation set. 

num_images = train_images.shape[0] * (1 - validation_split)
end_step = np.ceil(num_images / batch_size).astype(np.int32) * epochs

# Define o modelo para realizar a poda
pruning_params = {
      'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(initial_sparsity=0.50,
                                                               final_sparsity=0.80,
                                                               begin_step=0,
                                                               end_step=end_step)
}

model_for_pruning = prune_low_magnitude(model, **pruning_params)

# Quando utilizado o `prune_low_magnitude` é necessário recompilar o modelo.
model_for_pruning.compile(optimizer='adam',
              loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model_for_export = tfmot.sparsity.keras.strip_pruning(model_for_pruning)

# Realiza Fine tune no modelo pós poda
logdir = tempfile.mkdtemp()

callbacks = [
  tfmot.sparsity.keras.UpdatePruningStep(),
  tfmot.sparsity.keras.PruningSummaries(log_dir=logdir),
]

model_for_pruning.fit(train_images, train_labels,
                  batch_size=batch_size, epochs=epochs, validation_split=validation_split,
                  callbacks=callbacks)
model_for_export = tfmot.sparsity.keras.strip_pruning(model_for_pruning)

# Realiza compressão no modelo
converter = tf.lite.TFLiteConverter.from_keras_model(model_for_export)
pruned_tflite_model = converter.convert()

_, pruned_tflite_file = tempfile.mkstemp('.tflite')

with open(pruned_tflite_file, 'wb') as f:
  f.write(pruned_tflite_model)

Clustering de peso

Esse método é tão direto quanto seu próprio nome. Os pesos de cada camada da rede neural serão agrupados em N clusters, dentro desses clusters serão calculados os seus centroides e então os valores dos pesos são substituídos pelos respectivos centroides calculados.

Como é de se imaginar, o principal parâmetro dessa técnica é o valor de N. Quanto menor o valor de N, menos clusters serão criados e mais compacto será o modelo, porém mais a acurácia pode ser afetada.

Esse é um método que parece e de fato é muito simples, mas possui uma eficácia tão grande quanto os comentados anteriormente.

Aqui está um código onde é possível utilizar o método de clustering, mais detalhes podem ser encontrados no site do tensorflow:

import tensorflow_model_optimization as tfmot

cluster_weights = tfmot.clustering.keras.cluster_weights
CentroidInitialization = tfmot.clustering.keras.CentroidInitialization

clustering_params = {
  'number_of_clusters': 16,
  'cluster_centroids_init': CentroidInitialization.LINEAR
}

# Cluster a whole model
clustered_model = cluster_weights(model, **clustering_params)

# Use smaller learning rate for fine-tuning clustered model
opt = keras.optimizers.Adam(learning_rate=1e-5)

clustered_model.compile(
  loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
  optimizer=opt,
  metrics=['accuracy'])

clustered_model.summary()

Destilação de conhecimento (Knowledge destilation)

Este é o método que inicialmente aparenta ser o mais complexo e também mais “brilhante”. Seguindo o próprio nome o intuito é passarmos o conhecimento de um modelo complexo (pré-treinado) para um modelo menos complexo, assim mantendo a acurácia e diminuindo o seu tamanho.

O processo de destilação de conhecimento ocorre através do treinamento supervisionado, onde o modelo menor (aprendiz) será treinado em um conjunto de dados buscando “imitar” os resultados e representações internas do modelo mais complexo (professor). Para que seja possível o modelo aprendiz generalizar as informações contidas no modelo mais complexo, nesse período de treinamento o modelo busca imitar os resultados baseado em soft labels do modelo professor ao invés das hard labels, já que as soft labels possuem as probabilidades preditas para cada classe.

Utilizar as soft labels como principal referencia para o treinamento do modelo aprendiz permite que o modelo, em uma tarefa de classificação de imagens por exemplo, aprenda que a probabilidade de uma imagem de um “cachorro” ser classificada como “raposa” é maior do que ser classificada como um “rato”.

Conclusão

A compressão de modelos é uma área que sempre estará em pauta e em recorrentes atualizações com a criação de novos métodos, esses são apenas alguns que podem ser utilizados de forma eficaz até o atual momento.

Cada vez os modelos estão maiores, como os LLMs, e com isso a compressão será cada vez mais necessária para permitir que os modelos avancem de uma maneira que seja plausível e possibilite a sua utilização de diversas maneiras.

Compressão de modelo: Poda, clustering e destilação de conhecimento was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

Prompt e Engenharia de prompt são conceitos essenciais no campo da inteligência artificial generativa, neste artigo vamos nos aprofundar um pouco no que eles significam e como desempenham um papel importante na obtenção de resultados de alta qualidade nos modelos generativos.

Prompt

O prompt se refere a uma entrada ou instrução fornecida em formato de texto a um modelo de IA generativa, a fim de orientar e guiar sua saída. É como dar uma dica ou um contexto específico para que o modelo saiba exatamente o que você deseja que ele produza. Isso pode variar de consultas simples e diretas até declarações detalhadas para tarefas de alta complexidade.

No contexto de modelos de geração de imagens como o DALLE-3, os prompts são frequentemente descritivos, enquanto em LLMs como GPT-4 ou Gemini, podem variar de consultas simples até declarações de problemas de alta complexidade.

O que é a Engenharia de Prompt?

A engenharia de prompt é o processo de escrever, refinar e otimizar esses inputs para incentivar os sistemas de IA generativas a criar saídas de altíssima qualidade. Elaborar essas entradas ajudam o modelo a entender, não apenas a linguagem, mas também as nuances e as intenções por trás da solicitação, e esse é justamente o desafio de quem está trabalhando neste processo.

A qualidade do prompt influencia diretamente a qualidade do conteúdo gerado pela IA, seja ele um texto, uma imagem, um código fonte, entre outros tipos de retornos. Um prompt bem elaborado e refinado (após diversos experimentos) permite que o modelo produza resultados bastante precisos e relevantes, reduzindo a necessidade de revisões humanas pós geração do resultado.

A engenharia de prompt pode envolver técnicas avançadas como o “Chain-of-thought” e o “Reflection”.

“Chain-of-thought” ou “Cadeia de pensamentos”, é uma técnica que fornece um raciocínio de forma sistemática e em passo a passo para o modelo seguir. Ao demonstrar o processo de pensamento necessário para chegar a uma resposta, os modelos podem gerar saídas com maior riqueza de detalhes e precisão. Esse tipo de técnica pode ser utilizada para guiar modelos para a direção mais assertiva possível, mostrando como abordar um problema e como chegar a uma solução baseada na lógica, como por exemplo, a solução de uma equação:

Já o “Reflection”, “Self-Reflection” ou “Reflexão”, é uma técnica que através do feedback linguístico e humano, colocamos o modelo em um estado de auto-reflexão a respeito do seu resultado anterior, fornecendo contexto e possíveis melhorias para futuras consultas/respostas. Esse tipo de técnica, ajuda o modelo a aprender rapidamente com erros anteriores, levando a melhorias no desempenho em tarefas mais avançadas, ou respostas mais elaboradas. Seguindo o mesmo exemplo da técnica anterior, podemos utilizar o Reflection para fazer o modelo explicar de uma maneira mais clara:

Tipos de Prompt

Prompt Direto (Zero-Shot): é o tipo mais simples de prompt, ele não fornece exemplos ao modelo, apenas a instrução.

• Pergunta:

Quem foi o primeiro presidente dos Estados Unidos?

• Resposta:

George Washington.

Prompt com Exemplos (One-Shot, Few-Shot, Multi-Shot): Utilizam exemplos específicos para ajudar o modelo a focar e gerar respostas mais precisas

• Pergunta:

• Resposta:

Prompt de Função: Define um papel para o modelo, como se fosse um assistente ou um especialista em uma determinada área

• Pergunta:

Você é um tutor de matemática especializado em álgebra. Sua função é explicar passo a passo como resolver equações quadráticas de forma simples e clara para iniciantes. Explique o processo para resolver a seguinte equação: x² — 5x + 6 = 0

• Resposta:

Avançando um pouco mais no tópico de Engenharia de Prompt

Podemos trabalhar com os prompts por meio de uma interface feita pela empresa que disponibiliza o modelo (como por exemplo a OpenAI), em que nos limitamos somente a alguns tipos de técnicas, geralmente, estas empresas só disponibilizam o campo para digitar o prompt.

Porém, todavia, entretanto… Existem empresas que disponibilizam a API de seus modelos, o que torna as coisas ainda mais interessantes, pois isso abre um leque de possibilidades na engenharia de prompt!

Por meio da API, podemos configurar parâmetros para obtermos respostas ainda mais interessantes e assertivas. Trabalhar em cima desses parâmetros mais baixo nível requer um pouco mais de experimentos para descobrir as configurações mais adequadas para cada uso de prompt. Vamos passar por alguns destes métodos utilizados na engenharia de prompt quando interagimos com o LLM via API:

• Top-P (Nucleous Sampling): É um parâmetro que controla a diversidade da resposta, selecionando as ‘P’ palavras mais prováveis. Isso pode ajudar a evitar a alucinação do modelo, gerando respostas menos improváveis ou fora do contexto proposto no Prompt.
• Temperature: Este parâmetro controla a aleatoriedade das respostas geradas pelo modelo. Um valor mais alto de temperatura resulta em respostas com mais variação e maior criatividade, enquanto o valor mais baixo tende a produzir respostas mais previsíveis e conservadoras.
• Max_Tokens: Define o número máximo de tokens que o modelo pode gerar em resposta a um prompt. Isso é útil para limitar o comprimento da saída, garantindo que as respostas não sejam excessivamente longas.
• Frequency_Penalty: Reduz a probabilidade do modelo repetir a mesma palavra ou frase, incentivando a geração de palavras e frases com mais diversificação ao longo da resposta.

Como restringir o escopo dos prompts à aplicação?

Realizar a restrição de um escopo de Prompt de um LLM a uma aplicação específica pode ser um grande desafio devido à quantidade de dados que aquele modelo pode ter sido treinado e às diversas tarefas que o modelo pode realizar. Mas é essencial o domínio da engenharia de prompt para obter respostas relevantes e evitar com que essas informações fora de contexto sejam retornadas.

Para isso, pode-se pensar em estratégias como:

1. Contextualização
2. Instruções ricas em detalhes
3. Exemplos de Few-shot no prompt
4. Uso de Chain-of-Thought

Ou abordagens ainda mais avançadas, como por exemplo:

1. Implementação de Filtragem pós-processamento: Após a geração da resposta do modelo, utilize algoritmos adicionais para filtrar e verificar a relevância da resposta em relação ao domínio proposto.
2. Uso de modelos específicos de domínio: Utilize modelos que já foram treinados e ajustados especificamente para domínios parecidos com a aplicação. Por exemplo, um modelo especializado em linguagem médica para responder perguntas no contexto de saúde.
3. Fine-Tuning do modelo: Realize um fine-tuning do modelo utilizando um conjunto de dados especializado, e que abranja somente o domínio da aplicação. Isso vai ajudar o modelo a se tornar mais especializado no contexto proposto da aplicação.
4. RAG (Retrieval-Augmented Generation): O RAG é uma técnica que combina um modelo de recuperação de informações (Retriever) com um modelo de geração de texto (generator). A ideia é usar um modelo que busque informações relevantes em uma base de dados específicas, ou um conjunto de documentos, antes de enviar essas informações para um modelo de geração, a fim de produzir uma resposta final estritamente alinhada com o domínio da aplicação.

Quando usar prompts e quando realizar o fine-tuning de um LLM?

A escolha entre qual e quando utilizar, depende de diversos fatores, incluindo o contexto da aplicação, a complexidade da tarefa, quais os recursos estão disponíveis, e qual a necessidade de ter um modelo especializado.

Então, quando devo utilizar Prompt?

1. Aplicações de Baixa e Média complexidade (Tarefas gerais): Aplicações que não requerem respostas muito específicas ou complexas, os prompts geralmente são suficientes (responder perguntas em geral, gerar texto, fornecer resumos, etc…).
2. Flexibilidade: Ajustar rapidamente o comportamento do modelo sem treiná-lo novamente (Modificar o prompt conforme necessário).
3. Testes e Experimentos: Realizar testes e experimentos em diferentes modelos para avaliar a qualidade da saída (validar ideia sem investimento significativo de tempo e recurso).
4. Limitações de Recursos: Caso não exista um grande volume de dados ou hardware suficiente para treinar um modelo, utilizar prompt se torna muito prático e eficiente.

E quando devo fine-tunar um modelo?

1. Aplicações de alta complexidade e alta especialização: Se ter um alto grau de precisão, consistência e especialização na resposta, realizar o fine-tuning do modelo sem dúvidas é a melhor abordagem.
2. Melhorar desempenho em tarefas específicas: Permite que o modelo aprenda nuances de tarefas específicas que serão realizadas de uma maneira mais generalista por modelos genéricos.
3. Personalização: Quando é necessário que o modelo reflita regras de negócios, conhecimento institucional e etc… o fine-tuning permite que o modelo incorpore essas personalizações.
4. Controle e consistência de respostas: Permite um controle maior sobre o comportamento do modelo, garantindo respostas alinhadas com os objetivos da aplicação.
5. Desempenho: Aplicações que demandam uma alta performance e precisão, o fine-tuning melhora significativamente o resultado final.

E claro, utilizar um mix dessas abordagens pode trazer um desempenho ainda melhor. Se a aplicação permite um fine-tuning de um modelo para um domínio específico, é possível em seguida, utilizar prompts com alto nível de otimização baseado nas técnicas apresentadas anteriormente, para ajustar ainda mais o comportamento do modelo dentro do domínio esperado.

Prompt e Engenharia de Prompt was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introdução

Com a crescente influência da internet no processo de tomada de decisão dos consumidores, os comentários online têm se tornado uma fonte valiosa de informações para os usuários. No mercado de jogos, essa tendência não é diferente.

De acordo com um artigo publicado na revista “exame”, a decisão de compra de jogos está cada vez mais baseada em comentários na web [1]. Além disso, o mercado de jogos atualmente vale mais do que as indústrias de música e cinema juntas, conforme reportado pelo Canaltech [2].

No contexto específico da plataforma Steam, que é uma das principais plataformas de distribuição digital de jogos, a utilidade dos comentários dos usuários se torna ainda mais relevante. Os jogadores dependem desses comentários para obter informações sobre a qualidade, desempenho e experiência geral dos jogos antes de decidirem realizar uma compra.

Os comentários e a avaliação de utilidade

Na Steam, todo jogo pode ser avaliado e comentado pela comunidade. A foto acima mostra em azul se o autor recomendou ou não aquele jogo aos demais. Os usuários podem avaliar o comentário como útil ou não (em vermelho na imagem) e o número total de votos de utilidade é mostrado abaixo.

Por que prever a utilidade de comentários?

Vimos que avaliar a utilidade, então, é um processo manual. Isso pode estar sujeito a alguns problemas. Entre eles, destacam-se:

• Favorecimento de comentários não-úteis: Ao depender exclusivamente de avaliações manuais, existe o risco de que comentários que não agregam valor ou são irrelevantes sejam considerados úteis. Isso pode levar a uma percepção distorcida sobre a qualidade do conteúdo.

• Desfavorecimento de comentários úteis: Da mesma forma, ao avaliar manualmente a utilidade dos comentários, existe a possibilidade de que alguns comentários relevantes e informativos sejam erroneamente considerados como não úteis. Isso pode resultar em perda de insights valiosos fornecidos pelos usuários. Na imagem, um comentário que destaca diversos pontos como “história”, “jogabilidade” e “gráficos” e que aparenta ser muito útil, pode não ser avaliado pela comunidade. O que nos leva a outro ponto:
• Comentários pouco votados ou recentes passam despercebidos: Com a avaliação manual, há uma tendência de focar mais nos comentários populares ou bem estabelecidos, enquanto os comentários com menos votos ou mais recentes podem ser ignorados. Isso pode limitar a diversidade de opiniões e perspectivas consideradas na avaliação dos comentários.

Uma forma de contornar isso é prevendo a utilidade dos comentários com
ajuda do Processamento de Línguas de Naturais (PLN) !

Neste artigo, vamos explorar a previsão da utilidade de comentários em Português Brasileiro de jogos no site Steam. O objetivo é utilizar técnicas de Processamento de Linguagem Natural (PLN) e algoritmos de aprendizado de máquina para automatizar a classificação de comentários como úteis ou não-úteis.

Trabalhos relacionados

Alguns estudos anteriores já abordaram o tema da previsão da utilidade de comentários de jogos. Barbosa et al. (2016) utilizaram redes neurais artificiais para prever a utilidade de comentários em Português Brasileiro na Steam [3]. Baowaly et al. (2019) realizaram um estudo de caso na loja Steam, para prever a utilidade de avaliações de jogos[4].

Esses estudos serviram como base e inspiração para o nosso trabalho (Jorge e Pardo, 2022) [5], que teve como objetivos:

● Criação de um corpus anotado contendo comentários em Português Brasileiro de jogos na Steam.

● Automatizar a predição de utilidade de comentários por meio de algoritmos de aprendizado de máquina.

● Descobrir quais atributos linguísticos e não-linguísticos contribuem para definir um comentário como útil.

● Testar a hipótese e os métodos de Baowaly et al.(2019).

Pipeline

O pipeline do trabalho consiste em coletar comentários em jogos da plataforma Steam, realizar o pré-processamento dos dados, engenharia de atributos, vetorização dos comentários, treinamento de um modelo de aprendizado de máquina e avaliação do modelo. Essas etapas permitem a previsão da utilidade dos comentários e a análise dos atributos relevantes para essa previsão. Os detalhes mais específicos sobre cada etapa serão abordados logo após!

Método

Conjunto de dados

O conjunto encontra-se disponível no github! Fique a vontade para utilizá-lo e replicar os experimentos:

https://github.com/germanojorge/SteamBR

Para treinar e testar nosso algoritmo, coletamos um conjunto de dados contendo 2.789.893 comentários em Português Brasileiro de jogos na Steam. Utilizamos um web scraper para extrair esses dados do site. O conjunto de dados foi filtrado considerando apenas comentários com três ou mais votos, resultando em um total de 233.824 comentários. Os jogos foram divididos em 10 gêneros para uma melhor análise. O conjunto está disponível no github.

Pré-processamento

Antes de iniciar o treinamento do algoritmo, realizamos um pré-processamento nos comentários. Esse processo consistiu em transformar todas as letras em minúsculas, remover caracteres especiais, números e pontuações, realizar tokenização e remover stopwords, como “a”, “o” e “e”.

Engenharia de atributos

Na etapa de engenharia de atributos, definimos uma série de características para representar os comentários. Essas características foram divididas em três categorias: metadados, atributos semânticos e atributos distribucionais.

Os metadados incluíam informações como se o autor recomendou o jogo, o número de sentenças, o número de palavras, o tamanho médio das sentenças, o número de exclamações, o número de interrogações e a proporção entre letras maiúsculas e minúsculas.

Os atributos semânticos foram obtidos por meio da análise de sentimentos utilizando o dicionário LIWC, que contabiliza palavras que revelam determinados sentimentos e opiniões.

Já os atributos distribucionais foram gerados utilizando a técnica Doc2Vec, que transforma os comentários em vetores para capturar a semântica distribucional.

Aprendizado supervisionado

Utilizamos algoritmos de aprendizado de máquina para treinar e testar nosso modelo.

No aprendizado supervisionado, são inseridos comentários já rotulados como úteis e não úteis. Esses dados rotulados são utilizados para treinar o modelo de aprendizado de máquina, permitindo que ele aprenda a distinguir e prever a utilidade dos comentários com base nos padrões identificados nos dados de treinamento para quando inserirmos um comentário não rotulado.

Contudo, para treinar nosso modelo não basta colocar os comentários em sua forma “crua”, precisamos transformá-los em tabelas de instâncias e atributos. No nosso caso, durante a etapa da engenharia de atributos, já tínhamos feitos esse processo e transformado os comentários em vetores, além de extrair atributos como os metadados, e sentimentos, lembra?

Depois disso, precisamos escolher o algoritmo e dividir esse conjunto em treino e teste.

O algoritmo escolhido foi o Gradient Boosting Machine, que já havia sido utilizado por Baowaly et al. (2019) com bons resultados. Dividimos nosso conjunto de dados em 80% para treinamento e 20% para teste. Além disso, realizamos um balanceamento de classes utilizando as técnicas de oversampling e undersampling. Foram treinados um classificador e um regressor.

Um classificador é utilizado para categorizar os comentários como úteis ou não úteis, enquanto um regressor é usado para prever a pontuação de utilidade em uma escala contínua.

Resultados

Após realizar o treinamento e teste do modelo, obtivemos os seguintes resultados: a média do RMSE (Root Mean Square Error) foi de 0.95 para o regressor e a média do F1-score foi de 90% para o classificador. Esses resultados indicam que nosso modelo tem uma boa capacidade de prever a utilidade dos comentários.

a medida F1 representa uma métrica de avaliação que combina a precisão e a cobertura de um modelo de classificação. Ela é calculada a partir da média harmônica entre essas duas métricas e fornece uma medida geral do desempenho do modelo em relação à classificação correta das classes positivas e negativas. A precisão mede a proporção de verdadeiros positivos em relação ao total de exemplos classificados como positivos, enquanto a cobertura mede a proporção de verdadeiros positivos em relação ao total de exemplos verdadeiramente positivos. A medida F1 é especialmente útil quando há um desequilíbrio entre as classes de interesse, como no caso da previsão da utilidade dos comentários, em que os comentários úteis podem ser menos frequentes em comparação aos não úteis. Portanto, a medida F1 é uma métrica relevante para avaliar o desempenho do modelo na previsão da utilidade dos comentários em jogos.

Já a métrica RMSE (Root Mean Squared Error) é uma medida utilizada para avaliar o desempenho de modelos de regressão, como é o caso da previsão da pontuação de utilidade dos comentários. O RMSE mede a diferença média entre os valores previstos pelo modelo e os valores reais, levando em consideração o quadrado dessa diferença para garantir que valores positivos e negativos não se anulem. Em outras palavras, o RMSE representa a raiz quadrada da média dos erros quadrados, fornecendo uma medida de quão distante as previsões do modelo estão dos valores reais. Quanto menor o valor do RMSE, mais precisa é a previsão do modelo em relação à pontuação de utilidade dos comentários.

Ao analisar a importância dos atributos, verificamos que o número de palavras e a recomendação foram os atributos de maior relevância na previsão da utilidade dos comentários.

Conclusão

O presente trabalhou resultou em um artigo no BraSNAM — XII Brazilian Workshop on Social Network Analysis and Mining. E pode ser visualizado em: SteamBR: a dataset for game reviews and evaluation of a state-of-the-art method for helpfulness prediction

Neste trabalho, exploramos a previsão da utilidade de comentários em Português Brasileiro de jogos na Steam. Utilizando técnicas de PLN e algoritmos de aprendizado de máquina, conseguimos automatizar a classificação de comentários como úteis ou não-úteis.

Os resultados obtidos demonstram a viabilidade de utilizar essas técnicas para prever a utilidade dos comentários. A maior quantidade de dados utilizada no estudo contribuiu para melhorar a precisão do modelo. Além disso, identificamos que o número de palavras e a recomendação são os atributos mais importantes na previsão da utilidade dos comentários.

Esperamos que este estudo possa contribuir para uma melhor compreensão dos comentários em Português Brasileiro de jogos na Steam e auxiliar jogadores e desenvolvedores na tomada de decisões informadas.

Referências

[1] Decisão de compra é cada vez mais baseada em comentários na web. Disponível em: https://www.mundodomarketing.com.br/reportagens/comportamento-do-consumidor/25126/decisao-de-compra-e-cada-vez-mais-baseada-em-comentarios-na-web.html

[2] Mercado de games agora vale mais que indústrias de música e cinema juntas. Disponível em: https://canaltech.com.br/games/mercado-de-games-agora-vale-mais-que-industrias-de-musica-e-cinema-juntas-179455/

[3] Baowaly, M. K., Tu, Y. P., & Chen, K. T. (2019). Predicting the helpfulness of game reviews: A case study on the Steam store. Journal of Intelligent & Fuzzy Systems, 36(5), 4731–4742.

[4] Barbosa, J. L., Moura, R. S., & Santos, R. L. D. S. (2016, November). Predicting Portuguese steam review helpfulness using artificial neural networks. In Proceedings of the 22nd Brazilian Symposium on Multimedia and the Web (pp. 287–293).

[5] JORGE, Germano Antonio Zani. Prevendo a utilidade de comentários em portugês brasileiro de jogos no site Steam. 2022. Trabalho de Conclusão de Curso (MBA) — Instituto de Ciências Matemáticas e de Computação, Universidade de São Paulo, São Carlos, 2022. Disponível em: https://repositorio.usp.br/directbitstream/ac40baae-6351-49d9-8bdf-edfdb04c01c2/Germano%20Ant%C3%B4nio%20Zani%20Jorge_TCC_MBA_GERMANO_JORGE_COMPLETO_VERSAOFINAL_173931.pdf. Acesso em: 12 jun. 2023.

Prevendo a utilidade de comentários em Português Brasileiro de jogos na Steam was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

Os modelos de Deep Learning mais populares atualmente são conhecidos pela sua capacidade de realizar tarefas de alta complexidade e robustez. Entretanto por possuírem uma arquitetura composta de muitos pesos e neurônios, requerem uma quantidade considerável de recursos computacionais.

Utilizando a área de Processamento de Linguagem Natural (PLN) como exemplo, três dos modelos mais famosos e utilizados atualmente são BERT, T5 e GPT-3. Tais modelos são disponibilizados como modelos pré-treinados e podem ser ajustados para uma tarefa específica. Por serem considerados LLMs (ou Large Language Models), possuem uma arquitetura composta de milhões (ou bilhões) de parâmetros, como pode ser visto na tabela abaixo:

Uma das aplicações onde esses modelos podem ser utilizados é a tarefa de Análise de Sentimentos. A partir de um LLM pré-treinado, podemos realizar o processo de fine-tuning e obter um modelo capaz de classificar textos em um aplicativo móvel, por exemplo.

Mas quando a intenção é utilizar um LLM no contexto de uma aplicação móvel, podemos abordar o problema de duas formas: (i) mantendo uma conexão com um modelo disponibilizado na nuvem ou (ii) embarcando o modelo no próprio dispositivo. Esta última é um desafio a parte, dada as limitações de recurso e processamento que um dispositivo móvel oferece.

Seria inviável adicionar esse modelo com todos esses parâmetros, tamanho e custo computacional no aplicativo, pois um celular não possui os mesmos recursos computacionais que o ambiente onde o modelo foi treinado. Além disso, impactaria diretamente na latência, desempenho, consumo de memória, entre outros fatores do dispositivo.

Nesse sentido, técnicas de otimização são empregadas para reduzir a demanda de recursos computacionais sem prejudicar o desempenho do modelo ou a experiência do usuário. Neste artigo, falaremos sobre a Quantização, que reduz a complexidade dos pesos e vieses utilizados pelo modelo. Por exemplo, uma rede neural onde seus pesos e vieses comumente são utilizados em ponto de precisão, os mesmos serão convertidos para um tipo de dado de complexidade menor como o inteiro. No exemplo abaixo, pode-se observar um número em ponto flutuante de 32 bits, convertido para o número inteiro mais próximo de 8 bits, seguindo a ideia da quantização inteira pós treinamento que será melhor detalhada a frente.

TensorFlow Lite

Apenas lendo o conceito de quantização, pode-se imaginar que é uma transformação simples, mas devido a quantidade de parâmetros e pesos que esses modelos possuem, essa “simples” conversão resulta em uma alteração significante na arquitetura do modelo.

Uma das ferramentas disponíveis para quantização de modelos disponibilizadas é o TensorFlow Lite, disponível com mais informações nesse link. Alguns dos principais ganhos da quantização, especificamente utilizando TensorFlow Lite, são:

1. Menor latência: não há necessadade de conexão a um servidor;
2. Privacidade: nenhum dado do usuário sai do dispositivo;
3. Conectividade: não existe a necessidade de conexão a internet;
4. Tamanho reduzido: o modelo pode reduzir seu tamanho em até 75%;
5. Consumo de energia: diminuindo a complexidade também diminui o consumo de energia do aparelho;
6. Compatibilidade: é compatível com diferentes sistemas e dispositivos como Android, iOS e microcontroladores, além de possuir compatibilidade com diversas linguagens de programação, como: Java, C++ e Python.

O TensorFlow Lite possibilita a utilização de alguns tipos de quantização que serão detalhados a seguir, e dividem-se em dois principais tipos: quantização pós-treinamento e quantização “durante o treinamento” (aware training). Em resumo, se diferenciam porque a quantização pós-treinamento, como o próprio nome diz, é realizada após o treinamento do modelo e isso torna o processo mais simples. Já o método “aware training” é mais complexo e acontece no momento de inferência do modelo. Mas, em alguns casos, pode oferecer menor perda de acurácia do modelo em relação ao método pós-treinamento.

Neste artigo, abordaremos apenas o tipo quantização pós-treinamento, por ser a mais recomendada ao iniciar a utilização do TensorFlow Lite e também apresentar ganhos consistentes e desempenho similar ao método “aware training”.

Quantização pós-treinamento float16

Essa quantização é a mais simples, como mencionado anteriormente, os modelos neurais costumam trabalhar com dados em float32, nesse método esses pesos e vieses serão convertidos para float16. Como é de se esperar, o modelo terá uma redução de cerca de 50% do seu tamanho e a perda de precisão será praticamente nula.

Um ponto negativo dessa abordagem é que como a conversão dos dados é mínima, passando de float32 para float16, a latência e uso de memória do modelo não será tão otimizada quanto em outros métodos.

Os códigos para realizar a conversão dos modelos são muito simples. Nesse caso, é necessário apenas carregar o modelo original e depois especificar que a conversão será feita para float16.

import tensorflow as tf

#carrega o modelo original
converter = tf.lite.TFLiteConverter.from_saved_model(modelo_salvo)
converter.optimizations = [tf.lite.Optimize.DEFAULT]

#especifica para qual tipo será realizada a conversão (float16)
converter.target_spec.supported_types = [tf.float16]

#realiza a conversão
tflite_model = converter.convert()

Quantização de faixa dinâmica pós-treinamento

Este é um dos métodos mais indicados a serem utilizados, seus ganhos são muito significativos e a perda de acurácia é mínima. Nesta abordagem os dados são convertidos de float32 para int8, permitindo uma redução do tamanho do modelo em cerca de 75%. Enquanto os pesos e vieses são convertidos para int8 as saídas de ativação do modelo permanecem como ponto flutuante.

Esta é a conversão default do TFLite, por conta disso, não é necessário especificar o tipo que será realizada a conversão (int8) como no exemplo anterior.

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(modelo_salvo)

converter.optimizations = [tf.lite.Optimize.DEFAULT]

tflite_model = converter.convert()

Quantização inteira pós-treinamento

A quantização inteira é como uma extensão da quantização de faixa dinâmica, ela segue os mesmos princípios, mas além de converter os pesos e vieses do modelo para int8 as saídas de ativação do modelo também são convertidas, permitindo um tempo de inferência e latência ainda menores, sendo ideal para dispositivos de baixo poder computacional.

Este método possui uma diferença para os demais, para realizar a conversão completa de todos os dados de ponto flutuante do modelo é necessário utilizar uma amostragem dos dados de treinamento que irão auxiliar nessa conversão sem uma grande perca de acurácia. Normalmente, é uma pequena amostragem dos dados, como algumas centenas de dados escolhidos de forma randômica dos dados de treinamento ou validação.

import tensorflow as tf


converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]

#indica uma amostra do dataset que será utilizada na conversão
converter.representative_dataset = representative_dataset

#caso algo não possa ser convertido para int será indicado um erro
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]

#indica que as entradas e saídas do modelo serão convertida para int8
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8

tflite_model = converter.convert()

Salvando o modelo

Após realizar a conversão do modelo utilizando algum dos exemplos acima, podemos salvá-lo em seu novo formato tflite.

#indique o caminho onde deseja salvar o modelo .tflite
tflite_model_file = tflite_models_dir/"model_tflite.tflite"

#salva o modelo tflite_model gerado anteriormente no caminho acima
tflite_model_quant_file.write_bytes(tflite_model)

Após executar o código acima, o modelo estará convertido, salvo e pronto para ser utilizado em dispositivos como um modelo embarcado!

Neste artigo, abordamos a técnica de Quantização e sua utilidade em aplicações mobile e IoT, mostrando as possíveis quantizações utilizando a biblioteca TensorFlow Lit. No próximo artigo, vamos falar sobre uma outra técnica de compressão de modelos chamada “weight pruning” (ou poda de pesos) que funciona de forma diferente da quantização mas também apresenta resultados interessantes.

Compressão de modelo: Quantização was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

Se você já ouviu ou estudou sobre modelos pré treinados, já teve contato com Transfer Learning (TL).

Hoje, TL é uma parte fundamental de modelos de linguagem como Embeddings from Language Models (ELMo), Bidirectional Encoder representations from Transformers (BERT) e Text-to-Text Transfer Transformer (T5) — Os quais podem ser usados para qualquer tarefa decorrente de Processamento de Linguagem Natural (NLP).

Neste artigo, iremos entender o que é Transfer Learning, ver quais áreas existem para NLP e visitar rapidamente cada uma delas. O objetivo é introduzir os campos que o Transfer Learning aborda dentro de NLP e informar o leitor sobre a existência desses campos.

O que é Transfer Learning?

Transfer Learning é um método de machine learning onde um modelo desenvolvido para uma tarefa específica é reutilizado como ponto de início para a geração de um novo modelo em outra tarefa.

Transfer learning and domain adaptation refer to the situation where what has been learned in one setting … is exploited to improve generalization in another setting — Page 526, Deep Learning, 2016

É uma abordagem comum em Deep Learning, embora não exclusiva, e muito utilizada em tarefas de NLP já que desenvolver do zero grandes redes neurais têm um grande custo computacional e de tempo. Além do que, comparado com modelos treinados do zero, modelos pré treinados têm mostrado resultados muito melhores em diversas tarefas de NLP.

Transfer learning is the improvement of learning in a new task through the transfer of knowledge from a related task that has already been learned.

— Chapter 11: Transfer Learning, Handbook of Research on Machine Learning Applications, 2009

NLP é uma poderosa ferramenta, mas não é nada incomum na hora de criar um novo modelo, esbarrar em problemas de falta de dados ou se deparar com um modelo que não generaliza bem o suficiente. Nesse sentido, Transfer Learning nos permite resolver esses problemas.

Por que é útil e como se compara ao método tradicional?

Suponha que estamos fazendo um modelo para a tarefa de análise de sentimentos em um domínio de “avaliações de filmes”. Temos dados suficientes para a tarefa e treinamos um modelo que obtém ótimos resultados. Se aplicarmos esse modelo em outro conjunto de dados do mesmo domínio, esperamos ótimos resultados também.

Agora, se quisermos usar esse modelo de análise de sentimento para aplicar em um outro domínio, no domínio de “avaliações de produtos cosméticos”, é bem provável que o modelo já não tenha um desempenho tão bom quanto antes.

Se usarmos o paradigma tradicional apresentado na figura 1.1, vamos precisar coletar um córpus anotado e treinar um novo modelo.

Mas e se não tivermos córpus suficiente nesse novo domínio e não pudermos fazer um? E se quisermos adicionar uma outra classe no modelo , como o caso de neutros? E se não temos recursos computacionais suficientes ou tempo suficiente pra treinar um novo modelo?

Transfer Learning nos permite lidar com esses cenários trazendo o conhecimento que adquirimos no domínio/tarefa anterior para aplicarmos em uma nova.

Vamos dar uma definição formal para TL. Dado um domínio fonte Df, uma tarefa correspondente Tf, um domínio alvo Da e uma tarefa alvo Ta, o objetivo da transferência de aprendizado é nos possibilitar aprender a distribuição da probabilidade condicional do alvo P(Ya|Xa) em Da, com a informação adquirida em Df e onde Df≠Da ou Tf≠Ta

Áreas de Transfer Learning em NLP

Iremos explorar agora as diferentes áreas de TL para NLP propostas por Sebastian Rude (2019) que foram adaptadas da taxonomia geral de TL por Pan e Yang (2010)

Como visto na imagem acima, temos quatro áreas de TL separados em dois grupos, Inductive e Transductive TL.

Inductive TL vs Transductive TL

In the inductive transfer learning setting, the target task is different from the source task, no matter when the source and target domains are the same or not — page 3, Pan e Yang (2010)

No caso de inductive transfer learning, o objetivo é aprender uma tarefa nova, não importando se os domínios são os mesmos ou não. Os dados do domínio alvo Da precisam estar rotulados para induzir o modelo preditivo a funcionar no novo domínio.

Aqui vai a definição formal do inductive. Dado um domínio fonte Df e uma tarefa fonte Tf, um Da e uma tarefa alvo Ta, o inductive TL tem como objetivo melhorar o aprendizado da função preditora alvo Ff(.) em Da usando o conhecimento adquirido em Df e Tf, onde Tf≠Ta.

In the transductive transfer learning setting, the source and target tasks are the same, while the source and target domains are different — page 4, Pan e Yang (2010)

Já no transductive transfer learning queremos aprender domínios novos para a mesma tarefa. Uma característica importante é que não temos dados rotulados no Da, enquanto muitos dados do domínio fonte Df estão anotados.

Em outras palavras, dado um domínio fonte Df e uma tarefa de aprendizado correspondente Tf, um domínio alvo Da e uma tarefa Ta, o transductive TL tem como objetivo melhorar o aprendizado da função preditora Ff(.) em Da usando o conhecimento adquirido em Df e Tf, onde Df≠Da e Ta = Tf. Além disso, no momento do treinamento, pelo menos parte dos dados Da não podem estar rotulados.

Agora que demos uma passada rápida na definição dessas duas categorias, vamos abordar alguns dos tipos e suas aplicações em NLP.

E é claro: se quiser saber mais profundamente sobre as categorias Transductive e Inductive leia os trabalhos de Sebastian Rude (2019) e Pan e Yang (2010)

Domain Adaptation

Vamos então começar com o Domain Adaptation. Como o nome diz, o nosso objetivo é adaptar um modelo feito para uma tarefa específica treinado em um domínio Df, que agora queremos adaptar o conhecimento que temos para um novo domínio Da. Lembrando que a tarefa permanece a mesma por se tratar de transductive learning.

Normalmente, os estudos de como adaptar um domínio são feitos com um único domínio fonte, mas há também estudos lidando com vários domínios fontes.

Os métodos e abordagens para adaptar o modelo a um domínio, a partir de um único domínio fonte podem ser divididos em:
- Abordagens de representação;
- Ponderação e seleção de dados;
- Abordagens de auto-rotulação.

Porém, vou limitar este artigo a apenas nomear a existência dessas divisões. É uma tarefa muito difícil explicar essas abordagens em poucas linhas, por isso incentivo mais uma vez: se quiser ver a fundo os métodos, onde já foram aplicados e como são aplicados, sugiro que visite o trabalho de Sebastian Rude (2019).

No trabalho de Sebastian Rude, além dos três métodos acima, você pode encontrar também trabalhos sobre adaptação de domínio de múltiplos domínios fonte.

Cross-Lingual Transfer Learning

No Cross-lingual Transfer Learning, o objetivo é usar modelos e recursos em uma língua e transferí-los para outra lingua, mantendo a mesma tarefa.

Por exemplo: nos modelos zero-shot cross-lingual document classification, zero-shot aqui se refere a zero-shot learning — um paradigma onde o modelo aprende a reconhecer classes às quais não tinha sido apresentado antes e document classification é a tarefa de classificar um documento de acordo com certas classes, essas classes podendo ser, por exemplo, o tipo de texto. Nesta tarefa, o objetivo é treinar um modelo em uma língua e usá-lo para classificar o documento escrito em outra língua.

As técnicas de Cross-Lingual Transfer Learning são muito relevantes em cenários que exploram idiomas com poucos recursos/dados para serem trabalhados, agora, podem trazer conhecimento transferido de outras línguas que já tem bastante recursos, como o inglês.

Multi-Task Learning

Em aprendizado de máquina, se gerarmos um modelo para uma tarefa alvo, vamos dizer análise de sentimento, fazemos esse modelo apenas para essa tarefa. Mas será se não é possível que, ao gerar um modelo que performe múltiplas tarefas, possam surgir informações que nos ajudem a generalizar melhor a nosssa tarefa de análise de sentimento, fazendo com que obtenhamos resultados melhores?

Essa abordagem é chamada de Multi-Task Learning (MTL)

Multitask Learning is an inductive transfer method that improves generalization by learning extra tasks in parallel with the main task while using a shared representation; what is learned for the extra tasks can help the main task be learned better. — page 172, Multitask Learning, 1997

O interessante de MTL vem de usar os mesmos paramêtros para tarefas diferentes, o que nos dá duas principais formas de fazer isso.

Hard parameter sharing:
Esse é o método mais comum usado em MTL. Nesse método, as hidden layers são compartilhadas entre todas as tarefas enquanto as layers específicas para a tarefa são separadas.

Soft parameter sharing:
Nessa abordagem, cada tarefa tem seu próprio modelo e paramêtros. A distância entre os paramêtros é então regularizada para encorajá-los a serem similares.

O MTL não serve apenas para melhorar a performance de uma tarefa específica em base de várias tarefas auxiliares. Na verdade, ela funciona bem também quando o objetivo é realizar várias tarefas em paralelo.

Mas, no cenário de ter uma tarefa alvo com o objetivo de aumentar o seu desempenho, vale ressaltar que existem fatores para escolher tarefas auxiliares, sendo um deles o quão relacionadas elas são, como por exemplo: saber se a tarefa principal e a tarefa secundária compartilham as mesmas features (informação de baixo nível) para fazer predições.

Sequential Transfer Learning

Agora chegamos no famigerado Sequential Transfer Learning (STL), essa área envolve transferir conhecimento com uma sequência de passos, onde a tarefa alvo e a fonte não necessariamente são similares.

Diferente do MTL onde as tarefas são treinadas juntas, o STL consiste em dois estágios. Na primeira fase (pré treinamento), o modelo é treinado nos dados fontes, e na segunda fase (adaptação) o modelo é treinado na tarefa alvo.

O STL é um tema muito interessante, e é nele que iremos focar na segunda parte desta série. Assim, teremos a oportunidade de um mergulho num tópico que se encontra em alta e é infinitamente interessante.

Não deixe de acompanhar!

Agradecimentos

Francisca Ysabelle Manríquez pela revisão do texto

Transfer Learning: retrospectiva, abordagens e aplicações em NLP was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.

Análise de sentimentos (AS) é uma subárea do Processamento de Linguagem Natural (PLN) que, através de uma mineração contextual de dados, extrai informações subjetivas com a finalidade de entender os sentimentos, atitudes, emoções, avaliações e opiniões de pessoas a respeito de marcas, empresas, produtos, serviços, indivíduos, eventos, acontecimentos, entre outros.

Dentro da área de PLN, a AS carrega diversos desafios linguísticos, geralmente concentrados nos níveis da semântica acerca daquilo que está sendo analisado. Com a finalidade de se extrair um significado, a análise deve levar em consideração diversas possíveis estruturas de frases. As pessoas, quando se comunicam entre si, possuem muitas liberdades linguísticas, como as gírias, frases mais curtas e objetivas, palavras ou expressões que podem causar ambiguidade e ampliar a interpretação do que de fato aquilo significa.

A comunicação vai muito além de palavras e seus significados explícitos. Entre pessoas é muito complexa e repleta de nuances: uma sentença pode expressar diversos sentimentos em uma pessoa dependendo do contexto e da forma como foi escrita, demonstrando raiva, curiosidade, alegria, entusiasmo, frustração, tristeza e entre outros sentimentos que deverão ser compreendidos pela máquina.

Aprofundando na análise e entendendo os desafios

Podemos citar alguns níveis de “estudo” da língua como: Fonética e Fonologia, Sintaxe, Morfologia, Semântica, Discurso, etc. Como comentado anteriormente, as tarefas da Análise de Sentimentos estão concentradas no nível da semântica, onde a principal função é a extração ou conhecimento de um significado, e a semântica pode ser dividida em duas categorias: lexical e composicional.

A semântica lexical é a responsável por dar o significado de uma palavra naquele contexto em específico. Ou seja, se fizéssemos uma tarefa de classificação de polaridade para a frase “Aquele jogador é ok.”, iriamos classificá-la como positiva, pois o estrangeirismo “ok” qualifica “aquele jogador” positivamente.

Já quando estamos falando da procura da análise da ocorrência de composições lexicais, nos referimos a semântica composicional. Por exemplo, na sentença “O jogo foi fora de série.”, “fora”, é uma palavra que geralmente é, semanticamente falando, utilizada para representar algo negativo. “Série”, nessa frase, é absolutamente neutro. Porém, a expressão “fora de série”, se fossemos fazer outra tarefa de classificação de polaridade, indica admiração, algo que realmente foi melhor do que esperavam e, portanto, classificaríamos a sentença como positiva.

Aplicações com Análise de Sentimentos

Existem diversas aplicações práticas para a AS. Imagine possuir uma empresa e desenvolver uma solução que pode analisar o mercado e a competitividade dos produtos similares que outras empresas estão produzindo, ou também entender e identificar os pontos positivos e negativos do seu produto através dos comentários de seus consumidores que são feitos online, ou até mesmo trabalhar em um fator voltado para a política para analisar o sentimento das pessoas acerca daquilo que está sendo feito ou até mesmo entender as dores das pessoas e as reais necessidades sociais e a partir disso tomar decisões mais satisfatórias e assertivas no âmbito político de sua cidade.

O “objetivo” da Análise de Sentimentos é extrair o significado daquilo que a pessoa quis dizer, a associação das palavras, frases e textos e a relação disso com o significante. A compreensão e o estudo acerca dos desafios do PLN são herdados para a AS, principalmente os desafios de sintaxe, semântica e a classificação de polaridade.

Desafios da Análise de Sentimentos

Depois de citar o objetivo da AS e os desafios da análise semântica, é importante observar que existem alguns “obstáculos” para que esse objetivo seja alcançado. Alguns deles serão listados abaixo:

1. Sentimentos e opiniões são subjetivos;

2. Dependendo do contexto, as palavras podem ter o sentido contrário;

3. Existe uma enorme quantidade de fontes e formatos para obtenção dos dados;

4. Grande quantidade de linguagem informal;

5. As palavras podem conter duplo sentido.

Outro conceito importante é a definição do nível de granularidade da tarefa proposta. Essa definição pode ser dividida em três níveis para a análise de sentimentos: nível de documento, nível de sentença e nível de entidade.

Quando falamos de nível de documento, estamos nos referindo à análise completa de um texto. Dentro desse nível, a complexidade é de determinar a polaridade total que aquele documento representa. Como existem várias frases dentro de um texto com polaridades diferentes, dizer se ele é positivo, negativo ou neutro em sua totalidade acaba sendo um desafio a mais.

“A minha empresa tem um bom ambiente para se trabalhar, mas o salário é muito ruim.”

No exemplo acima, foi-se extraída uma frase de um texto, onde é possível notar que, apenas nela, foram identificadas polaridades diferentes: “bom”, sendo algo positivo e “ruim”, negativo. Isso corrobora o grande desafio em determinar a polaridade total do texto.

O nível de sentença, como o nome sugere, é a análise da extração da polaridade de apenas uma sentença. Ela pode ser considerada como uma etapa intermediária para a análise de nível de documento, uma vez que a composição de todas as sentenças pode indicar aquilo que o texto quer dizer e qual é a polaridade geral dele.

O nível de entidade (ou aspecto) é aquele em que se busca reconhecer quais são os atributos da entidade principal de determinada opinião. Esse nível é geralmente usado em tarefas de sumarização de opiniões.

Classificação de Polaridade

Agora, trataremos mais especificamente de um problema de polaridade, que envolve entender as opiniões de usuários e classificá-las em um conjunto de classes. Este problema é amplamente estudado e compreendido, pois se trata de algo muito comum no nosso dia a dia. Em diversos lugares, podemos observar um uso muito claro dessa classificação, como: reviews de filmes, livros, aplicativos e produtos nos mais diversos marketplaces.

Uma das divisões que podemos observar é a divisão de três classes: positivo, neutro e negativo. Essas divisões são um grande desafio na análise de sentimentos: quanto maior o número de classes, mais complexos se tornam os métodos de classificação, mesmo para nós seres humanos; pois isso faz com que o custo da anotação de corpora de sentimentos aumente também. As divisões podem chegar a quatro ou até cinco classes.

A imagem anterior exemplifica muito bem a complexidade e os desafios da análise de sentimentos e como são classificadas as polaridades dentro das frases. De um lado, temos “A pizza é muito boa” — o que traz um sentimento positivo em relação à pizza. E do outro lado, “mas a entrega demorou muito” carrega um sentimento negativo em relação ao serviço.

Nesse caso, não conseguimos apenas pela frase saber se, no geral, essa é uma opinião positiva ou negativa. Ela tem seus pontos positivos e também negativos. Mas, como notamos, é possível classificar a polaridade das frases de acordo com as palavras, sentimentos e emoções que elas expressam.

Para concluir, a Análise de Sentimentos, que é uma subárea do Processamento de Linguagem Natural com o objetivo de entender sentimentos, emoções e avaliações a respeito de pessoas, coisas, produtos e outros, tem seus desafios e complexidades em relação à analise semântica de níveis de granularidade.

Classificar a polaridade de frases, textos, documentos, também são problemas enfrentados pela AS, pelo fato de todos eles carregarem consigo opiniões subjetivas e emocionais, podendo elas serem positivas, neutras ou negativas. Uma sentença pode ter tanto “partes” positivas quanto negativas e, pode até existir aquelas em que, apesar de parecerem positivas, dependendo do contexto, se “tornam” negativas.

Neste artigo, introduzimos a fundamentação teórica da Análise de Sentimentos e gostaríamos de convidar a todos a lerem o próximo, onde vamos mostrar uma aplicação prática do que foi abordado neste. Fique atento e não perca!

Introdução à Análise de Sentimentos (parte 1) was originally published in SiDi NLP on Medium, where people are continuing the conversation by highlighting and responding to this story.