Visualização de dados de LLMs
Machine learning é uma das principais áreas da inteligência artificial (IA). E as redes neurais são um dos principais algoritmos de machine learning. No mundo atual orientado por IA, entender o comportamento de grandes modelos de linguagem (LLMs) como o LLaMA é crucial. Assim como ocorre com outros algoritmos de machine learning, as redes neurais conhecidas como LLMs pode ser analisadas com técnicas de visualizações.
Neste post, nos aprofundaremos no mundo da visualização de padrões dos textos gerados pelo LLaMA. A visualização é uma ferramenta poderosa para entender padrões de dados complexos. Para realizá-la, aproveitaremos o poder do Matplotlib e do Scikit-learn para descobrir os segredos do LLaMA. Mas note: as técnicas que usaremos neste post não se restringem ao LLaMA. Elas podem ser usadas com qualquer outro LLM como o Gemma, Qwen, Granite 3.0 da IBM, etc.
O que é LLaMA?
LLaMA (Large Language Model) é um modelo de linguagem de ponta desenvolvido pela Meta. Ele entende e gera textos semelhantes aos humanos. Suas aplicações incluem resposta a perguntas, classificação de textos e tradução de idiomas.
Por que visualizar padrões de resposta?
A visualização de padrões de resposta oferece insights sobre como o LLaMA processa e gera textos. Ao analisar esses padrões, podemos:
Identificar vieses: descobrir possíveis falhas no comportamento do modelo que podem afetar seu desempenho.
Otimizar o desempenho do LLM: tomar decisões baseadas em dados para melhorar a precisão e a eficácia do modelo.
Dados do LLaMA para visualização
Antes de começar, precisamos de alguns dados para visualizar. Para esse post, simplesmente pedimos para o LlaMA gerar 100 perguntas para uma entrevista de emprego para uma vaga de desenvolvedor Python com conhecimento de IA e LLM. Essa quantidade de texto não seria adequada para uma análise real, mas ela serve para propósitos de demonstração.
O LlaMA foi instruído a gerar 10 perguntas sobre 10 temas que deveriam ser abordado na entrevista. O próprio LLM determinou os 10 temas (eles foram usados na visualização com 10 classes). Eles foram: Python, IA, LLM, projetos, diversidade, segurança, colaboração, recurso, bibliotecas Python e desenvolvimento.
Para a sua visualização, use os dados de textos gerados pelo LLaMA (ou por outro LLM) que tiver. O importante é que o conjunto de dados escolhido tenha uma coluna de textos gerados pelo modelo e uma com a classificação de cada exemplo como explicado acima. Abaixo, mostramos alguns exemplos de textos e suas classes correspondentes (coluna da direita).
0 Qual é a sua experiência com Python? 1
1 Você já trabalhou com Inteligência Artificial?... 1
2 Quais são os principais conceitos de IA que vo... 1
3 Como você acredita que a IA pode ser usada par... 1
4 Qual é a sua opinião sobre a relação entre a I... 1
Matplotlib e Scikit-learn para visualização de textos de LLM
Com os dados em mãos, a análise é bem direta. Num código Python, importe os pacotes necessários e abra seus dados. Abaixo, assumimos que eles estão em formato CSV. Se esse não for o caso, mude o código de acordo. Em seguida, usamos TfidfVectorizer para transformar os dados de texto em representações vetoriais. Portanto, você deve selecionar apenas os dados de texto nessa fase (os textos gerados pelo LLaMA). No nosso caso, eles correspondem a coluna 1 do dataFrame do pandas (df.iloc[:,1]) . As classes não entram.
from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd
import matplotlib.pyplot as plt
df = pd.read_csv('SEUS_DADOS.csv')
# Cria vetorizador TF-IDF
vectorizer = TfidfVectorizer(max_features=1000)
# Ajusta e transforma as respostas
response_vectors = vectorizer.fit_transform(df.iloc[:,1])
Redução de dimensionalidade com t-SNE
Em seguida, usamos t-SNE para realizar a redução de dimensionalidade dos dados para conseguir visualizá-los. Apenas os dados de textos transformados em vetores são usados nessa fase.
from sklearn.manifold import TSNE
# Aplica t-SNE
tsne = TSNE(n_components=2)
response_tsne = tsne.fit_transform(response_vectors.toarray())
A partir da redução de dimensionalidade feita com t-SNE, plotamos um gráfico de dispersão 2D em que cada ponto representa uma resposta e a cor indica uma categoria dos dados. Esse tipo de gráfico mostra como as respostas se agrupam. Veja um exemplo de código de como plotá-lo:
plt.figure(figsize=(6, 4))
scatter = plt.scatter(response_tsne[:, 0], response_tsne[:, 1],
c=df.iloc[:,2], # suas classes entram aqui
cmap='viridis', alpha=0.7)
plt.colorbar(scatter)
plt.title("padrões de resposta LLaMA")
plt.xlabel("dimensão t-SNE 1")
plt.ylabel("dimensão t-SNE 2")
plt.show()
Esse foi o resultado obtido:
Note que, nessa etapa, usamos as classes para a visualização (linha 5 no código acima). Se suas classes não estiverem convertidas em valores numéricos, converta-as antes de usá-las. Para isso, você pode usar o método LabelEncoder() do scikit-learn.
Análise de clusters
from sklearn.cluster import KMeans
# Verifica agrupamento (clusters) com K-means
kmeans = KMeans(n_clusters=5)
cluster_labels = kmeans.fit_predict(response_vectors)
# Visualiza os clusters
plt.figure(figsize=(6,4))
scatter = plt.scatter(response_tsne[:, 0], response_tsne[:, 1],
c=cluster_labels, cmap='Set1', alpha=0.7)
plt.colorbar(scatter)
plt.title("Clusters de resposta LLaMA")
plt.xlabel("dimensão t-SNE 1")
plt.ylabel("dimensão t-SNE 2")
plt.show()
Esses foram os resultados obtidos:
Com os clusters identificados, podemos usá-los para identificar as principais palavras associadas a cada um deles. Assim, conseguimos entender melhor o comportamento do LLM. Veja como imprimir as palavras:
# imprime as palavras principais dos clusters
def top_terms_kmeans(vectorizer, kmeans, n=10):
feature_names = vectorizer.get_feature_names_out()
for i in range(kmeans.n_clusters):
centroid = kmeans.cluster_centers_[i]
top_indices = centroid.argsort()[-n:][::-1]
print(f"Principais {n} termos para cluster {i}:")
print(", ".join(feature_names[j] for j in top_indices))
print()
top_terms_kmeans(vectorizer, kmeans)
Este código imprime as principais palavras associadas a cada cluster. E aqui estão os resultados para os dados que usamos:
Principais 10 termos para cluster 0:
quais, principais, são, as, python, habilidades, necessárias, em, llms, de
Principais 10 termos para cluster 1:
usados, podem, os, acredita, ser, melhorar, como, recursos, para, que
Principais 10 termos para cluster 2:
relação, opinião, entre, sobre, sua, qual, inteligência, artificial, humana, criatividade
Principais 10 termos para cluster 3:
seu, papel, mais, importante, projetos, qual, em, de, com, ia
Principais 10 termos para cluster 4:
pode, você, usada, de, que, como, experiência, acredita, ser, melhorar
Essa visualização ajuda a interpretar os padrões nas respostas do LLaMA. Evidentemente, podemos utilizar os mesmos procedimentos para analisar respostas de outros LLMs. Independentemente do LLM analisado, as visualizações revelam padrões em suas respostas para diferentes categorias.
Conclusão
Visualizar os padrões de resposta do LlaMA ou de outros LLMs é uma ferramenta poderosa para entender seu comportamento. As análises que mostramos auxiliam a identificar temas ou estilos comuns nas saídas do modelo e também como suas respostas se agrupam. Esse tipo de análise auxilia na depuração do modelo e na otimização de parâmetros. Por exemplo, podemos usá-la como base para ajustar a temperatura usada na geração de respostas para calibrar sua criatividade. Além disso, a visualização também pode ser usada para mostrar a qualidade, quantidade e composição de dados de treinamento. Essa etapa é particularmente importante quando precisamos realizar ajuste fino do LLM. A qualidade dos dados é essencial para essa tarefa.
