Como tornar qualquer LLM mais preciso em apenas algumas linhas de código

A revolução da IA estava em formação há décadas. Era um campo cheio de empolgação, mas muitas vezes pontuado por decepções e “ invernos de IA ”. Mas, recentemente, algo mudou. Large Language Models (LLMs) como ChatGPT, Claude e Bard catapultaram a IA da curiosidade de laboratório para o mainstream .

Essa mudança não foi apenas um triunfo da IA, mas também uma vitória sobre as complexidades de dados grandes e confusos. Como diz o ditado, “lixo entra, lixo sai”. Novas ferramentas estão surgindo com foco na melhoria dos dados subjacentes, melhorando, portanto, os LLMs.

O duplo desafio dos LLMs

O termo "Large Language Models" encerra em si dois grandes desafios. Primeiro, o grande volume de dados. Estamos falando de mais de um petabyte (um milhão de gigabytes) de dados para GPT-4, abrangendo milhões de livros, blogs, postagens em mídias sociais, transcrições de vídeo e muito mais. Essa escala colossal oferece um vasto potencial, mas também apresenta considerações logísticas significativas.

Em segundo lugar, a complexidade da linguagem natural. Dados de linguagem dependentes de contexto, ambíguos e diversos são uma fera que até mesmo os melhores algoritmos lutam para domar. É impossível rotular com precisão todos esses dados, o que inevitavelmente significa que mesmo os LLMs de última geração são treinados em toneladas de dados rotulados incorretamente.

Ao enfrentar esses desafios, novas ferramentas e metodologias centradas em dados surgiram, permitindo um verdadeiro salto no que a IA é capaz. Soluções como Cleanlab e outras começaram a oferecer maneiras de coletar diversos dados, automatizar o controle de qualidade e processar a linguagem em um formato adequado para modelos de IA.

Essas ferramentas não ofereciam apenas melhorias incrementais; eles reformularam fundamentalmente a abordagem de tratamento de dados de IA. Eles transformaram a tarefa de lidar com dados de linguagem em grande escala de um processo manual e sujeito a erros em um processo automatizado e preciso, democratizando o campo e permitindo avanços em um ritmo sem precedentes.

Por que a IA centrada em dados é necessária (com uma demonstração do Python)

Na IA, os conjuntos de dados do mundo real contêm erros de anotação que variam de 7 a 50% . Essas imperfeições dificultam significativamente o treinamento e a avaliação. A IA centrada em dados enfatiza a melhoria da qualidade do próprio conjunto de dados.

A estratégia da OpenAI, por exemplo, ilustra essa ênfase: “Priorizamos a filtragem de todos os dados ruins em vez de deixar todos os dados bons. Isso ocorre porque sempre podemos ajustar nosso modelo com mais dados posteriormente para ensiná-lo coisas novas, mas é muito mais difícil fazer o modelo esquecer algo que já aprendeu.”

Uma abordagem de filtragem manual de dados, no entanto, é demorada e cara. O pacote Cleanlab é uma estrutura de código aberto popular para a prática de IA centrada em dados atualmente. Ele permite que você execute algoritmos de qualidade de dados nas saídas de seu modelo de ML treinado para detectar problemas comuns de conjunto de dados, como erros de rótulo, outliers, desvios e muito mais.

Com apenas algumas linhas de código, você pode encontrar e identificar automaticamente problemas em vários tipos de dados, como imagem, texto, tabular e áudio. Usando o pacote Cleanlab, você pode decidir como melhorar seu conjunto de dados e modelo, treinar novamente seu modelo de ML e ver seu desempenho melhorar sem nenhuma alteração em seu código existente.

O Cleanlab Studio, por outro lado, é mais do que apenas uma extensão do pacote Cleanlab; é uma plataforma sem código projetada para encontrar e corrigir problemas em conjuntos de dados do mundo real. Ele não para apenas na detecção de problemas, mas vai além ao lidar com a curadoria e correção de dados e até automatiza quase todas as partes difíceis de transformar dados brutos em ML ou Analytics confiáveis.

Vamos usar o pacote Cleanlab para demonstrar o poder da IA centrada em dados.

1. Preparação de dados e ajuste fino

Começamos com o conjunto de dados de cortesia de Stanford . Certifique-se de ter os conjuntos de treinamento e teste carregados. Nesta demonstração, ajustaremos o Davinci LLM para classificação de 3 classes, primeiro sem o Cleanlab, e depois veremos como podemos melhorar a precisão com o foco nos dados. Podemos executar um comando bash simples para treinar um modelo.

!openai api fine_tunes.create -t "train_prepared.jsonl" -v "test_prepared.jsonl" --compute_classification_metrics --classification_n_classes 3 -m davinci --suffix "baseline"

Feito isso, podemos consultar um endpoint fine_tunes.results para ver a precisão do teste.

!openai api fine_tunes.results -i ft-9800F2gcVNzyMdTLKcMqAtJ5 > baseline.csv

`df = pd.read_csv('baseline.csv')

baseline_acc = df.iloc[-1]['classificação/precisão']`

Obtemos um resultado de 63% de precisão. Vamos ver se podemos melhorar isso.

2. Obter probabilidades de classe previstas

Agora, vamos usar a API do OpenAI para calcular incorporações e ajustar um modelo de regressão logística para obter probabilidades de classe previstas fora da amostra.

# Get embeddings from OpenAI. from openai.embeddings_utils import get_embedding

embedding_model = "text-similarity-davinci-001" train["embedding"] = train.prompt.apply(lambda x: get_embedding(x, engine=embedding_model)) embeddings = train["embedding"].values

# Get out-of-sample predicted class probabilities via cross-validation.

from sklearn.linear_model import LogisticRegression

model = LogisticRegression() labels = train["completion"].values pred_probs = cross_val_predict(estimator=model, X=embeddings, y=labels, cv=10, method="predict_proba")

Com apenas uma linha de código, o Cleanlab estima quais exemplos têm problemas de rótulo em nosso conjunto de dados de treinamento.

from cleanlab.filter import find_label_issues

Agora podemos obter índices de exemplos estimados com problemas de rótulo:

issue_idx = find_label_issues(labels, pred_probs, return_indices_ranked_by='self_confidence') # sort indices by likelihood of label error

3. Filtrar problemas de etiqueta e treinar novamente

Agora, extraímos automaticamente os índices de exemplos potencialmente rotulados incorretamente, para que possamos removê-los e treinar um novo classificador.

# Remove the label errors

train_cl = train.drop(issue_idx).reset_index(drop=True) format_data(train_cl, "train_cl.jsonl")

Agora vamos treinar um classificador mais robusto com dados melhores.

!openai api fine_tunes.create -t "train_cl_prepared.jsonl" -v "test_prepared.jsonl" --compute_classification_metrics --classification_n_classes 3 -m davinci --suffix "dropped"

# Evaluate model on test data

!openai api fine_tunes.results -i ft-InhTRQGu11gIDlVJUt0LYbEx > cleanlab.csv df = pd.read_csv('cleanlab.csv') dropped_acc = df.iloc[-1]['classification/accuracy']

Obtemos uma precisão de mais de 66%, melhorando um modelo de ajuste fino de última geração (GPT-3, pois você não pode ajustar o GPT-4), apenas melhorando automaticamente o conjunto de dados, sem qualquer alteração ao modelo.

Com o Cleanlab Studio, também é possível corrigir automaticamente os rótulos incorretos em vez de apenas removê-los, melhorando ainda mais a precisão. Um guia da Cleanlab mostra que isso leva a precisão de até 77%.

Aprendizado

Usando ferramentas centradas em dados como o Cleanlab, você pode encontrar e corrigir problemas de dados e rótulos com eficiência, levando a melhorias significativas no desempenho de LLMs como o Davinci. Essa abordagem não altera a arquitetura do modelo ou os hiperparâmetros e se concentra apenas em melhorar a qualidade dos dados de treinamento.

A abordagem descrita neste guia pode ser a chave para desbloquear ainda mais precisão e robustez em modelos de IA, mesmo com futuros LLMs avançados como GPT-5.