Instalar e carregar dependencias

Vamos instalar as bibliotecas accelerate e bitsandbytes que possibilitam a quantização de LLMs e algumas bibliotecas do framework LangChain

!pip install accelerate
!pip install -i https://pypi.org/simple/ bitsandbytes
!pip install langchain langchain_huggingface langchain_community langchain_chroma

Carregar bibliotecas

import pandas as pd
import torch 
import re

from sklearn.metrics import accuracy_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain_core.prompts.few_shot import PromptTemplate, FewShotPromptTemplate
from langchain_core.example_selectors import SemanticSimilarityExampleSelector
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_chroma import Chroma

Carregar funções auxiliares

Carregar uma função para limpeza simples dos tweets.

def clean_tweet(text):
    """
    src: https://github.com/lrdsouza/told-br-classifier
    """
    text = text.replace('rt @user', '')
    text = text.replace('@user', '')
    pattern = re.compile('[^a-zA-Z0-9\sáéíóúàèìòùâêîôûãõçÁÉÍÓÚÀÈÌÒÙÂÊÎÔÛÃÕÇ]')
    text = re.sub(r'http\S+', '', text)
    text = pattern.sub(r' ', text)
    text = text.replace('\n', ' ')
    text = ' '.join(text.split())
    return text

Preparar dados

Aplicar limpeza básica para preparar os tweets.

train['text'] = train.text.apply(lambda x: clean_tweet(x))
valid['text'] = valid.text.apply(lambda x: clean_tweet(x))
test['text'] = test.text.apply(lambda x: clean_tweet(x))

Preparar modelo

Os modelos da Hugging Face podem ser facilmente executados localmente utilizando a classe HuggingFacePipeline. O Hugging Face Model Hub é um repositório que abriga mais de 120 mil modelos, 20 mil conjuntos de dados e 50 mil aplicativos de demonstração (Spaces), todos de código aberto e disponíveis publicamente. Esta plataforma online permite que as pessoas colaborem facilmente e construam modelos de machine learning juntas.

# Instanciar um pipeline transformers
pipe = pipeline(
    model=model,
    tokenizer=tokenizer,
    task="text-generation",
    max_new_tokens=1,
)

# Passar o pipeline para a classe do LangChain
llm = HuggingFacePipeline(pipeline=pipe)

Preparar exemplos

Selecionaremos os exemplos candidatos do conjunto de dados de treino que não estejam no dataset de validação. Cada exemplo de entrada deve ser um dicionario onde:

• key: o nome das variáveis de inputs do prompt;
• values: os valores dos inputs.

# indices de instancias que nao estao no dataset de validacao (evitar leak)
idx_train_examples = train.loc[~train.index.isin(valid.index)].index

# organizar a lista com os exemplos candidatos
examples = [{'tweet': train.text[i], 
             'label': str(train.label[i])} for i in idx_train_examples]

Criar template para os exemplos com PromptTemplate

Agora precisamos instanciar um PromptTemplate para nosso prompt, que recebe um template das instruções que desejamos passar para o LLM e os inputs que alimentam este template:

example_template = """
Tweet: {tweet}
Label: {label}
"""

# Instanciar o exemplo de prompt 
example_prompt = PromptTemplate(
    input_variables=["tweet", "label"], 
    template=example_template
)

Inserir exemplos com ExampleSelector

Agora vamos instanciar SemanticSimilarityExampleSelector para selecionar exemplos com base em sua semelhança com a entrada. Ele usa um modelo de embedding para calcular a similaridade entre a entrada e os exemplos de few-shot, bem como um armazenamento de vetores Chroma para realizar a pesquisa do vizinho mais próximo de maneira eficiente.

example_selector = SemanticSimilarityExampleSelector.from_examples(
    examples = examples,
    embeddings = embeddings,
    vectorstore_cls = Chroma,
    k=3,
)

Aumentar o número de vizinhos mais próximos não garantirá necessariamente resultados melhores. Normalmente k=6 no máximo já é suficiente. Se não conseguir bons resultados assim, já seria mais indicado realizar um ajuste fino mesmo.

Preparar o FewShotPromptTemplate

Finalmente, vamos definir a formatação para a apresentação dos exemplos e, em seguida, usar FewShotPromptTemplate para para gerar o template final que será utilizado como prompt com base nos valores de entrada.

prefix = """The following tweets are written in Brazilian Portuguese. \n\
You are a tweet classifier that identifies \
toxic language as 1 and non-toxic language as 0. \n\
Here are some examples:"""

suffix = """
Tweet: {tweet} 
Label: """

prompt = FewShotPromptTemplate(
    example_selector=example_selector,
    example_prompt=example_prompt,
    prefix=prefix,
    suffix=suffix,
    example_separator='\n',
    input_variables=["tweet"],
)

Vejamos como será a formatação do prompt para a classificação de cada tweet:

print(prompt.format(tweet=valid.head(1).text.values[0]))

## The following tweets are written in Brazilian Portuguese. 
## You are a tweet classifier that identifies toxic language as 1 and non-toxic language as 0. 
## Here are some examples:
## 
## Tweet: caralho eu tenho q fazer alguma coisa mt importante mas eu esqueci o que é então n deve ser importante
## Label: 1
## 
## Tweet: caralho as pessoas fazem me sentir a pessoa mais bosta e odiada possível eu tô bem
## Label: 0
## 
## Tweet: tenho quase certeza que isso e um homem escroto fingindo ser mulher kkkkkkkkk por um momento eu tbm pensei nisso
## Label: 0
## 
## Tweet: vei se um filho faz isso cmg eu pego o sanduíche e enfio no cu dele
## Label: 

Definir Custom Output Parsers

Para concluir a cadeia, vamos definir uma função que funcione como um Custom Output Parser, que será responsável por pegar a saída do LLM e transformá-la no formato mais adequado para nosso caso. Precisamos apenas do último caractere que será retornado pelo LLM.

def parse(response):
    """Retorna apenas o ultimo caracter da saída do LLM"""
    return int(response[-1:])

Definir Cadeira LangChain

Chains referem-se à sequências de chamadas - seja para um LLM, uma etapa de pré-processamento de dados, tools, ou ainda etapas de pós-processamento do output gerado pelo modelo. As cadeias construídas desta forma são boas porque oferecem suporte nativo a streaming, assincrono e inferência em batchs para uso.

chain = prompt | llm | parse

Vamos testar o comportamento da nossa cadeia em 1 tweet:

print(f"""Tweet: {valid.head(1).text.values[0]}
Label: {valid.head(1).label.values[0]}
Predict: {chain.invoke({'tweet':  valid.head(1).text.values[0]})}""")

## Tweet: vei se um filho faz isso cmg eu pego o sanduíche e enfio no cu dele
## Label: 1
## Predict: 1

Claramente um conteúdo tóxico e que foi classificado corretamente. Mas como queremos realizar a chamada da nossa cadeia para diversos tweets do dataset de test, utilizaremos o método .batch() que executa a cadeia para uma lista de entradas:

%%time
valid['predict'] = chain.batch([{'tweet': x} for x in valid.text])

## CPU times: user 1min 26s, sys: 24.8 s, total: 1min 51s
## Wall time: 1min 50s

Avaliar resultados

Como a métrica de avaliação da competição era a acurácia, vamos dar uma olhada em como ficou a matriz de confusão:

# Calcular métricas
cm = confusion_matrix(valid.label, valid.predict)
acc=accuracy_score(valid.label, valid.predict)

# Configurações de estilo do seaborn
sns.set(font_scale=1.2)
plt.figure(figsize=(5, 3))

# Plotar Matriz de Confusão para o método Vader em inglês
sns.heatmap(cm, annot=True, fmt='d', cmap='binary', cbar=False,vmin=0, vmax=50,
            xticklabels=['Não Tóxico', 'Tóxico'], yticklabels=['Não Tóxico', 'Tóxico'])
plt.title(f'Matriz de Confusão\nAcurácia: {acc:.0%}', fontsize=22)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.xlabel('Previsto', fontsize=14)
plt.ylabel('Real', fontsize=14)
plt.show()