Guia Mozilla AI lançado com exemplo de código de resumo – Mozilla Hacks

O Mozilla AI Guide foi lançado e convidamos você a ler e se familiarizar com ele. Você pode acessá-lo aqui

Nossa visão é que o Guia de IA seja o ponto de partida para cada novo desenvolvedor no espaço e um lugar para revisitar em busca de clareza e inspiração, garantindo que as inovações de IA enriqueçam a vida cotidiana. O foco inicial do AI Guide começa com modelos de linguagem e o objetivo é tornar-se um recurso colaborativo conduzido pela comunidade que abrange outros tipos de modelos.

Para iniciar as primeiras seções do Mozilla AI Guide, aprofunde-se nas perguntas mais frequentes sobre Large Language Models (LLMs). AI Basics cobre os conceitos de IA, ML, LLMs, o que esses conceitos significam e como eles estão relacionados. Esta seção também analisa os prós e os contras do uso de um LLM. O Language Models 101 continua a desenvolver o conhecimento compartilhado dos fundamentos da IA ​​e se aprofunda no próximo nível com modelos de linguagem. Ele responderá a perguntas como “O que significa ‘treinar’ um modelo de ML” ou “O que é a abordagem ‘humano no circuito’?”

Iremos para a última seção sobre Escolha de modelos de ML e demonstraremos no código abaixo o que pode ser feito usando modelos de código aberto para resumir determinado texto. Você pode acessar o Caderno Colab aqui ou continuar lendo:

Primeiros passos com modelos de linguagem

Ao contrário de outros guias, este foi desenvolvido para ajudar a escolher o modelo certo para o que você está tentando fazer:

• ensinando como permanecer sempre atualizado nas pesquisas publicadas sobre IA
• ampliando sua perspectiva sobre as opções abertas atuais para qualquer tarefa
• não estar vinculado a um modelo de linguagem grande de código fechado/dados fechados (ex OpenAI, Anthropic)
• criando um sistema baseado em dados para sempre identificar e usar o modelo de última geração (SOTA) para qualquer tarefa específica.

Vamos nos concentrar na “resumo de texto” como nossa primeira tarefa.

Então… por que não estamos usando um dos modelos populares de linguagem grande?

Ótima pergunta. A maioria dos LLMs disponíveis que se prezem podem realizar muitas tarefas, incluindo resumo, mas nem todos eles podem ser bons no que você deseja especificamente que eles façam. Deveríamos descobrir como avaliar se eles realmente podem ou não.

Além disso, muitos dos atuais LLMs populares não são abertos, são treinados com base em dados não divulgados e apresentam preconceitos. O uso responsável da IA ​​exige escolhas cuidadosas e estamos aqui para ajudá-lo a fazê-las.

Finalmente, a maioria dos grandes LLMs requer computação GPU poderosa para ser usada. Embora existam muitos modelos que você pode usar como serviço, a maioria deles custa dinheiro por chamada de API. Desnecessário quando algumas das tarefas mais comuns podem ser realizadas com boa qualidade com modelos abertos já disponíveis e hardware disponível no mercado.

Por que o uso de modelos abertos é importante?

Nas últimas décadas, os engenheiros foram abençoados com a capacidade de embarcar, começando com projetos de código aberto e, eventualmente, enviando o código aberto para produção. Este estado padrão está agora em risco.

Sim, existem muitos modelos abertos disponíveis que fazem um ótimo trabalho. No entanto, a maioria dos guias não discute como começar a usá-los usando etapas simples e, em vez disso, prefere APIs fechadas existentes.

O financiamento está fluindo para projetos comerciais de IA, que têm orçamentos maiores do que os contribuidores de código aberto para comercializar seu trabalho, o que inevitavelmente leva os engenheiros a começarem com projetos de código fechado e enviarem projetos fechados caros para produção.

Nosso primeiro projeto – Resumo

Nós vamos:

• Encontre um texto para resumir.
• Descubra como resumi-los usando os modelos de código aberto de última geração.
• Escreva algum código para fazer isso.
• Avalie a qualidade dos resultados usando métricas relevantes

Para simplificar, vamos pegar Diretrizes de IA confiável da Mozilla em forma de string

Observe que no mundo real, você provavelmente terá que usar outras bibliotecas para extrair conteúdo de qualquer tipo de arquivo específico.

import textwrap

content = """Mozilla's "Trustworthy AI" Thinking Points:

PRIVACY: How is data collected, stored, and shared? Our personal data powers everything from traffic maps to targeted advertising. Trustworthy AI should enable people to decide how their data is used and what decisions are made with it.

FAIRNESS: We’ve seen time and again how bias shows up in computational models, data, and frameworks behind automated decision making. The values and goals of a system should be power aware and seek to minimize harm. Further, AI systems that depend on human workers should protect people from exploitation and overwork.

TRUST: People should have agency and control over their data and algorithmic outputs, especially considering the high stakes for individuals and societies. For instance, when online recommendation systems push people towards extreme, misleading content, potentially misinforming or radicalizing them.

SAFETY: AI systems can carry high risk for exploitation by bad actors. Developers need to implement strong measures to protect our data and personal security. Further, excessive energy consumption and extraction of natural resources for computing and machine learning accelerates the climate crisis.

TRANSPARENCY: Automated decisions can have huge personal impacts, yet the reasons for decisions are often opaque. We need to mandate transparency so that we can fully understand these systems and their potential for harm."""

Ótimo. Agora estamos prontos para começar a resumir.

Uma breve pausa para contexto

O espaço da IA ​​está se movendo tão rápido que é necessário uma enorme atualização de artigos científicos todas as semanas para compreender a configuração do terreno e o estado da arte.

É um esforço para um engenheiro que é novo na IA:

• descubra quais modelos abertos existem por aí
• quais modelos são apropriados para qualquer tarefa específica
• quais benchmarks são usados ​​para avaliar esses modelos
• quais modelos têm bom desempenho com base nas avaliações
• quais modelos podem realmente rodar no hardware disponível

Para o engenheiro que trabalha com prazo determinado, isso é problemático. Não há muito discurso centralizado sobre como trabalhar com modelos de IA de código aberto. Em vez disso, existem threads X fragmentados (anteriormente Twitter), grupos privados aleatórios e muita transferência boca a boca.

No entanto, assim que tivermos um fluxo de trabalho para resolver todos os itens acima, você terá os meios para estar para sempre na era da pesquisa publicada em IA.

Como obtenho uma lista de modelos de resumo abertos disponíveis?

Por enquanto, recomendamos o Huggingface e seu grande diretório de modelos abertos divididos por tarefa. Este é um ótimo ponto de partida. Observe que LLMs maiores também estão incluídos nessas listas, portanto teremos que filtrar.

Nesta enorme lista de modelos de sumarização, quais escolhemos?

Não sabemos em que nenhum desses modelos é treinado. Por exemplo, um resumidor treinado em artigos de notícias em vez de postagens no Reddit terá um desempenho melhor em artigos de notícias.

O que precisamos é de um conjunto de métricas e benchmarks que possamos usar para fazer comparações comparativas desses modelos.

Como avalio modelos de resumo?

As etapas abaixo podem ser usadas para avaliar qualquer modelo disponível para qualquer tarefa. Por enquanto, é necessário alternar entre algumas fontes de dados, mas tornaremos isso muito mais fácil no futuro.

Passos:

1. Encontre os conjuntos de dados mais comuns usados ​​para treinar modelos para resumo.
2. Encontre as métricas mais comuns usadas para avaliar modelos para resumo nesses conjuntos de dados.
3. Faça uma auditoria rápida sobre a origem, a qualidade dos dados de treinamento e quaisquer preconceitos exibidos, para manter-se alinhado com o uso responsável da IA.

Encontrando conjuntos de dados

A maneira mais fácil de fazer isso é usar Papers With Code, um excelente recurso para encontrar os artigos científicos mais recentes por tarefa que também possuem repositórios de código anexados.

Primeiro, filtre os conjuntos de dados de “resumo de texto” do Papers With Code pelos conjuntos de dados em inglês baseados em texto mais citados.

Vamos escolher (no momento em que este artigo foi escrito) o conjunto de dados mais citado – o conjunto de dados “CNN/DailyMail”. Geralmente o mais citado é um marcador de popularidade.

Agora, você não precisa baixar este conjunto de dados. Mas vamos revisar as informações que o Papers With Code forneceu para aprender mais sobre isso na próxima etapa. Este conjunto de dados também está disponível no Huggingface.

Você deseja verificar três coisas:

• licença
• artigos recentes
• se os dados são rastreáveis ​​e os métodos são transparentes

Primeiro, verifique a licença. Neste caso, é licenciado pelo MIT, o que significa que pode ser utilizado tanto para projetos comerciais quanto pessoais.

A seguir, veja se os artigos que utilizam este conjunto de dados são recentes. Você pode fazer isso classificando os documentos em ordem decrescente. Este conjunto de dados específico contém muitos artigos de 2023 – ótimo!

Finalmente, vamos verificar se os dados vêm de uma fonte confiável. Neste caso, o conjunto de dados foi gerado pela IBM em parceria com a Universidade de Montreal. Ótimo.

Agora, vamos ver como podemos avaliar modelos que usam esse conjunto de dados.

Avaliando modelos

A seguir, procuramos métricas medidas que sejam comuns aos conjuntos de dados para a tarefa de resumo. MAS, se você não está familiarizado com a literatura sobre resumo, não tem ideia do que seja.

Para descobrir, escolha uma “Subtarefa” que se aproxime do que você gostaria de ver. Gostaríamos de resumir o artigo da CNN que mostramos acima, então vamos escolher “Resumo de Texto Abstrativo”.

Agora estamos no negócio! Esta página contém uma quantidade significativa de novas informações.

Há menções a três novos termos: ROUGE-1, ROUGE-2 e ROUGE-L. Essas são as métricas usadas para medir o desempenho do resumo.

Há também uma lista de modelos e suas pontuações nessas três métricas – é exatamente isso que procuramos.

Supondo que estamos considerando ROUGE-1 como nossa métrica, agora temos os 3 principais modelos que podemos avaliar com mais detalhes. Todos os 3 estão próximos de 50, o que é uma pontuação promissora do ROUGE (leia no ROUGE).

Testando um modelo

OK, temos alguns candidatos, então vamos escolher um modelo que será executado em nossas máquinas locais. Muitos modelos obtêm seu melhor desempenho quando executados em GPUs, mas há muitos que também geram resumos rapidamente em CPUs. Vamos escolher um deles para começar – Pégaso do Google.

# first we install huggingface's transformers library
%pip install transformers sentencepiece

Então encontramos Pegasus em Huggingface. Observe que parte dos conjuntos de dados nos quais o Pegasus foi treinado inclui CNN/DailyMail, o que é um bom presságio para o resumo do nosso artigo. Curiosamente, há uma variante do Pegasus do Google que só é treinada em nosso conjunto de dados preferido, devemos usá-la.

from transformers import PegasusForConditionalGeneration, PegasusTokenizer 
import torch 

# Set the seed, this will help reproduce results. Changing the seed will 
# generate new results 
from transformers import set_seed 
set_seed(248602) 

# We're using the version of Pegasus specifically trained for summarization 
# using the CNN/DailyMail dataset 
model_name = "google/pegasus-cnn_dailymail"

# If you're following along in Colab, switch your runtime to a
# T4 GPU or other CUDA-compliant device for a speedup
device = "cuda" if torch.cuda.is_available() else "cpu" 

# Load the tokenizer
tokenizer = PegasusTokenizer.from_pretrained(model_name) 

# Load the model 
model = PegasusForConditionalGeneration.from_pretrained(model_name).to(device)

# Tokenize the entire content
batch = tokenizer(content, padding="longest", return_tensors="pt").to(device)

# Generate the summary as tokens
summarized = model.generate(**batch)

# Decode the tokens back into text
summarized_decoded = tokenizer.batch_decode(summarized, skip_special_tokens=True)
summarized_text = summarized_decoded[0]

# Compare
def compare(original, summarized_text):
  print(f"Article text length: {len(original)}\n")
  print(textwrap.fill(summarized_text, 100))
  print()
  print(f"Summarized length: {len(summarized_text)}")

compare(content, summarized_text)

Article text length: 1427

Trustworthy AI should enable people to decide how their data is used.values and goals of a system
should be power aware and seek to minimize harm.People should have agency and control over their
data and algorithmic outputs.Developers need to implement strong measures to protect our data and
personal security.

Summarized length: 320

Tudo bem, temos algo! Mas meio curto. Vamos ver se conseguimos tornar o resumo mais longo…

set_seed(860912)

# Generate the summary as tokens, with a max_new_tokens
summarized = model.generate(**batch, max_new_tokens=800)
summarized_decoded = tokenizer.batch_decode(summarized, skip_special_tokens=True)
summarized_text = summarized_decoded[0]

compare(content, summarized_text)

Article text length: 1427

Trustworthy AI should enable people to decide how their data is used.values and goals of a system
should be power aware and seek to minimize harm.People should have agency and control over their
data and algorithmic outputs.Developers need to implement strong measures to protect our data and
personal security.

Summarized length: 320

Bem, isso realmente não funcionou. Vamos tentar uma abordagem diferente chamada ‘amostragem’. Isso permite que o modelo escolha a próxima palavra de acordo com sua distribuição de probabilidade condicional (especificamente, a probabilidade de que essa palavra siga a palavra anterior).

Também definiremos o ‘temperatura’. Esta variável funciona para controlar os níveis de aleatoriedade e criatividade na saída gerada.

set_seed(118511)
summarized = model.generate(**batch, do_sample=True, temperature=0.8, top_k=0)
summarized_decoded = tokenizer.batch_decode(summarized, skip_special_tokens=True)
summarized_text = summarized_decoded[0]
compare(content, summarized_text)

Article text length: 1427

Mozilla's "Trustworthy AI" Thinking Points:.People should have agency and control over their data
and algorithmic outputs.Developers need to implement strong measures to protect our data.

Summarized length: 193

Mais curto, mas a qualidade é superior. Ajustar a temperatura provavelmente ajudará.

set_seed(108814)
summarized = model.generate(**batch, do_sample=True, temperature=1.0, top_k=0)
summarized_decoded = tokenizer.batch_decode(summarized, skip_special_tokens=True)
summarized_text = summarized_decoded[0]
compare(content, summarized_text)

Article text length: 1427

Mozilla's "Trustworthy AI" Thinking Points:.People should have agency and control over their data
and algorithmic outputs.Developers need to implement strong measures to protect our data and
personal security.We need to mandate transparency so that we can fully understand these systems
and their potential for harm.

Summarized length: 325

Agora vamos brincar com outra abordagem de geração chamada topo_k amostragem – em vez de considerar todas as próximas palavras possíveis no vocabulário, o modelo considera apenas as próximas ‘k’ palavras mais prováveis.

Essa técnica ajuda a focar o modelo em prováveis ​​continuações e reduz as chances de gerar texto irrelevante ou sem sentido.

Atinge um equilíbrio entre criatividade e coerência, limitando o conjunto de escolhas da palavra seguinte, mas não tanto que o resultado se torne determinístico.

set_seed(226012)
summarized = model.generate(**batch, do_sample=True, top_k=50)
summarized_decoded = tokenizer.batch_decode(summarized, skip_special_tokens=True)
summarized_text = summarized_decoded[0]
compare(content, summarized_text)

Article text length: 1427

Mozilla's "Trustworthy AI" Thinking Points look at ethical issues surrounding automated decision
making.values and goals of a system should be power aware and seek to minimize harm.People
should have agency and control over their data and algorithmic outputs.Developers need to
implement strong measures to protect our data and personal security.

Summarized length: 355

Finalmente, vamos tentar topo_p amostragem – também conhecida como amostragem por núcleo, é uma estratégia em que o modelo considera apenas o menor conjunto de palavras principais cuja probabilidade cumulativa excede um limite ‘p’.

Diferente top_k que considera um número fixo de palavras, topo_p adapta-se com base na distribuição de probabilidades para a próxima palavra. Isso o torna mais dinâmico e flexível. Ajuda a criar um texto diversificado e sensato, permitindo que palavras menos prováveis ​​sejam selecionadas quando as mais prováveis ​​não somam ‘p’.

set_seed(21420041)
summarized = model.generate(**batch, do_sample=True, top_p=0.9, top_k=50)
summarized_decoded = tokenizer.batch_decode(summarized, skip_special_tokens=True)
summarized_text = summarized_decoded[0]
compare(content, summarized_text)

# saving this for later.
pegasus_summarized_text = summarized_text

Article text length: 1427

Mozilla's "Trustworthy AI" Thinking Points:.People should have agency and control over their data
and algorithmic outputs.Developers need to implement strong measures to protect our data and
personal security.We need to mandate transparency so that we can fully understand these systems
and their potential for harm.

Summarized length: 325

Para continuar com o exemplo de código e ver um teste com outro modelo e aprender como avaliar os resultados do modelo de ML (uma outra seção), clique aqui para visualizar o Python Notebook e clique em “Abrir no Colab” para experimentar seu próprio código personalizado.

Observe que este guia será constantemente atualizado e novas seções sobre recuperação de dados, geração de imagens e ajuste fino serão lançadas a seguir.

As contribuições dos desenvolvedores são vitais

Pouco depois do lançamento de hoje do Guia Mozilla AI, publicaremos nossas diretrizes de contribuição da comunidade. Ele fornecerá orientação sobre o tipo de conteúdo que os desenvolvedores podem contribuir e como ele pode ser compartilhado. Prepare-se para compartilhar quaisquer excelentes projetos, implementações, modelos de vídeo e áudio de IA de código aberto.

Juntos, podemos reunir uma comunidade de IA coesa, colaborativa e responsável.

Um agradecimento especial a Kevin Li e Pradeep Elankumaran que elaboraram esta excelente postagem no blog.