Tamanho do modelo

Para saber qual modelo utilizar, primeiramente precisamos ter em mente algumas noções sobre a quantidade de parâmetros e tamanhos dos LLM. No geral:

Para uma análise de sentimentos simples, não é necessário um modelo com 100 bilhões de parâmetros. Modelos menores, como os com 7 bilhões de parâmetros, podem ser suficientes e menos computacionalmente exigentes.

Código aberto ou fechado

Embora próximos, os LLMs de código aberto ainda não conseguem igualar o poder e a precisão dos aplicativos de código fechado disponíveis comercialmente, como GPT-4 e Bard (Gemini). Mesmo sendo menos poderosos, existem alguns prós e contras pelos quais podemos pesar na hora de escolher a melhor opção:

Utilizaremos a abordagem de código aberto por ser mais prática para fins de estudos, pois além de gratuita, não exige internet, registros ou chaves de API.

Uso remoto ou local

Podemos interagir com o modelo de linguagem grande (LLM) do Llama 2 via API da Hugging Face, seguindo as instruções do repositório oficial da Meta ou podemos baixar os arquivos do modelo em formato GGML para o Llama 2 7B Chat do Meta Llama 2. Os formatos GGML são utilizados para inferência de CPU + GPU usando o principamente o pacote llama-cpp-python.

Para mais informações sobre como configurar o modelo consulte este link

def load_llama_model(model_path="./input/llama-2-7b-chat.ggmlv3.q2_K.bin", language='en', seed=42):
    # Determinar o tamanho da janela de contexto com base no idioma
    if language == 'en':
        context_window = df.text_en.map(len).max()
    elif language == 'pt':
        context_window = df.text_pt.map(len).max()
    else:
        raise ValueError("Language must be 'en' or 'pt'.")

    # Carregar o modelo Llama
    return Llama(model_path=model_path,
                 verbose=False,
                 n_ctx=context_window,
                 seed=seed)

Para obter os melhores resultados, devemos ser o mais claro e específicos possível nas interações. Porém devemos iniciar com um prompt simples e rápido para ir direcionando o modelo na direção desejada e avaliando os resultados obtidos e ajustando gradualmente o prompt para refinar e aprimorar a resposta desejada

def classify_sentiment_llama(text, llama_model):
    # Construir a prompt para o modelo Llama
    prompt = f''' \
    Q: Answer with just one word, \
    does the following text express a \
    positive or negative feeling? \
    {text} \
    A:'''
    # Obter a saída do modelo Llama
    output = llama_model(prompt, max_tokens=3)
    return output["choices"][0]["text"]

Com nosso prompt definido, já podemos carregar o modelo:

# Carregar o modelo Llama para o idioma desejado
llama_model = load_llama_model(language='en')

## llama.cpp: loading model from ./llama-2-7b-chat.ggmlv3.q2_K.bin
## llama_model_load_internal: format     = ggjt v3 (latest)
## llama_model_load_internal: n_vocab    = 32000
## llama_model_load_internal: n_ctx      = 4320
## llama_model_load_internal: n_embd     = 4096
## llama_model_load_internal: n_mult     = 256
## llama_model_load_internal: n_head     = 32
## llama_model_load_internal: n_head_kv  = 32
## llama_model_load_internal: n_layer    = 32
## llama_model_load_internal: n_rot      = 128
## llama_model_load_internal: n_gqa      = 1
## llama_model_load_internal: rnorm_eps  = 5.0e-06
## llama_model_load_internal: n_ff       = 11008
## llama_model_load_internal: freq_base  = 10000.0
## llama_model_load_internal: freq_scale = 1
## llama_model_load_internal: ftype      = 10 (mostly Q2_K)
## llama_model_load_internal: model size = 7B
## llama_model_load_internal: ggml ctx size =    0.08 MB
## llama_model_load_internal: mem required  = 2733.66 MB (+ 2160.00 MB per state)
## llama_new_context_with_model: kv self size  = 2160.00 MB
## llama_new_context_with_model: compute buffer total size =  295.35 MB

Após instanciar o modelo, basta aplicá-lo em nossa base de dados. (apliquei o mesmo modelo tanto para as reviews e português quanto em inglês).

df['sentiment_llm_en'] = df.text_en.progress_apply(lambda x: classify_sentiment_llama(x, llama_model))

Como este modelo é o mais básico e não alteramos nenhum parâmetro (como por exemplo temperature, que determina se o output será mais aleatório ou mais previsível) pode ser que a saída não saia padronizada e necessite de algum pós-processamento. Vejamos como foram os outputs do LLM:

# Contagem da frequência das classificações
sentiment_llm_counts = df.groupby('sentiment').sentiment_llm_en.value_counts().reset_index(name='n')

# Organizar as categorias pela frequência total
order = df.sentiment_llm_en.value_counts().reset_index(name='n')
order = order.sort_values(by='n', ascending=False)['index']

# Configurações de estilo do seaborn
sns.set(style="whitegrid")

# Criar o gráfico de barras
plt.figure(figsize=(12, 4))
ax = sns.barplot(x=sentiment_llm_counts.sentiment_llm_en, y=sentiment_llm_counts.n, hue=sentiment_llm_counts.sentiment, order=order, palette=["red", "green"])

# Adicionar rótulos e título
plt.ylim([0, 25])
plt.xticks(fontsize=12, rotation=90)
plt.yticks(fontsize=12)
ax.set_xlabel('Anotação de sentimento das resenhas', fontsize=14)
ax.set_ylabel('Frequência', fontsize=14)
ax.set_title('Frequência dos sentimentos classificados pelo LLM em Inglês\nem relação aos sentimentos já anotados da base', fontsize=20)

# Adicionar anotações nas barras
for p in ax.patches:
    ax.annotate(f'{p.get_height()}', (p.get_x() + p.get_width() / 2., p.get_height()),
                ha='center', va='baseline', fontsize=10, color='black', xytext=(0, 5),
                textcoords='offset points')

plt.legend(loc="upper right", title = "Label real")

# Remover bordas da parte superior e direita
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.grid(False)

# Salvar a nuvem de palavras como imagem
plt.savefig(f"img/freq_class_llm_en.png", bbox_inches='tight')

# Exibir o gráfico
plt.show()

Como a saída não foi padronizada, vamos realizar algum pós-processamento para padronizar as classes como pos ou neg para possibilitar avaliar o desempenho do modelo com base em métricas de classificação.

conditions = [
    (df.sentiment_llm_en.str.contains('(?i)(?:pos|fun)')),
    (df.sentiment_llm_en.str.contains('(?i)(?:neg|horrible|melanchol)'))
]
pd.crosstab(df.sentiment, np.select(conditions, ['pos', 'neg'], default='other'))

Com os outputs padronizados em duas classes, podemos verificar como foi a acurácia do modelo.

Desempenho

Como estamos diante de um problema de classificação, avaliaremos o desempenho do modelo com matrizes de confusão para entender a as taxas de acerto e calcular a acurácia pois o dataset é balanceado.

# Matrizes de Confusão
conditions = [
    (df.sentiment_llm_en.str.contains('(?i)(?:pos|fun|good|comedy)')),
    (df.sentiment_llm_en.str.contains('(?i)(?:neg|melanchol|absurd|horrible)'))
]
cm_llm_en = confusion_matrix(df.sentiment, np.select(conditions, ['pos', 'neg'], default='other'))
accuracy_llm_en = accuracy_score(df.sentiment, np.select(conditions, ['pos', 'neg'], default='other'))

conditions = [
    (df.sentiment_llm_pt.str.contains('(?i)(?:pos)')),
    (df.sentiment_llm_pt.str.contains('(?i)(?:neg|horrível)'))
]
cm_llm_pt = confusion_matrix(df.sentiment, np.select(conditions, ['pos', 'neg'], default='other'))
accuracy_llm_pt = accuracy_score(df.sentiment, np.select(conditions, ['pos', 'neg'], default='other'))

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

# Plotar Matriz de Confusão para o modelo de LLM em inglês
plt.subplot(1, 2, 1)
sns.heatmap(cm_llm_en, annot=True, fmt='d', cmap='binary', cbar=False, vmin=0, vmax=50,
            xticklabels=['Negativo', 'Neutro', 'Positivo'], yticklabels=['Negativo', 'Neutro', 'Positivo'])
plt.title(f'Matriz de Confusão (Vader - Inglês)\nAcurácia: {accuracy_llm_en:.0%}', fontsize=22)
plt.xlabel('Previsto', fontsize=14)
plt.ylabel('Real', fontsize=14)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)

# Plotar Matriz de Confusão para o modelo de LLM em português
plt.subplot(1, 2, 2)
sns.heatmap(cm_llm_pt, annot=True, fmt='d', cmap='binary', cbar=False,vmin=0, vmax=50,
            xticklabels=['Negativo', 'Neutro', 'Positivo'], yticklabels=['Negativo', 'Neutro', 'Positivo'])
plt.title(f'Matriz de Confusão (Vader - Português)\nAcurácia: {accuracy_llm_pt:.0%}', fontsize=22)
plt.xlabel('Previsto', fontsize=14)
plt.ylabel('Real', fontsize=14)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)

# Ajustar layout
plt.tight_layout()

# Salvar a nuvem de palavras como imagem
plt.savefig(f"img/cm_llm.png", bbox_inches='tight')

# Exibir o gráfico
plt.show()

O desempenho deste modelo é muito interessante, principalmente por já ser pré treinado, não sendo necessário gastar tanto tempo na sua construção mas para afirmar que este modelo é bom precisamos entender qual seria o resultado para resolver este problemas se utilizassemos a abordagem mais simples possível.

Desempenho

Como estamos diante de um problema de classificação, avaliaremos o desempenho do modelo com matrizes de confusão para entender a as taxas de acerto e calcular a acurácia pois o dataset é balanceado.

# Matrizes de Confusão
cm_vader_en = confusion_matrix(df.sentiment, df.sentiment_vader_en)
cm_vader_pt = confusion_matrix(df.sentiment, df.sentiment_vader_pt)

# Acurácias
accuracy_vader_en = accuracy_score(df.sentiment, df.sentiment_vader_en)
accuracy_vader_pt = accuracy_score(df.sentiment, df.sentiment_vader_pt)

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

# Plotar Matriz de Confusão para o método Vader em inglês
plt.subplot(1, 2, 1)
sns.heatmap(cm_vader_en, annot=True, fmt='d', cmap='binary', cbar=False,vmin=0, vmax=50,
            xticklabels=['Negativo', 'Neutro', 'Positivo'], yticklabels=['Negativo', 'Neutro', 'Positivo'])
plt.title(f'Matriz de Confusão (Vader - Inglês)\nAcurácia: {accuracy_vader_en:.0%}', fontsize=22)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.xlabel('Previsto', fontsize=14)
plt.ylabel('Real', fontsize=14)

# Plotar Matriz de Confusão para o método Vader em português
plt.subplot(1, 2, 2)
sns.heatmap(cm_vader_pt, annot=True, fmt='d', cmap='binary', cbar=False,vmin=0, vmax=50,
            xticklabels=['Negativo', 'Neutro', 'Positivo'], yticklabels=['Negativo', 'Neutro', 'Positivo'])
plt.title(f'Matriz de Confusão (Vader - Português)\nAcurácia: {accuracy_vader_pt:.0%}', fontsize=22)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.xlabel('Previsto', fontsize=14)
plt.ylabel('Real', fontsize=14)

# Ajustar layout
plt.tight_layout()

# Salvar a nuvem de palavras como imagem
plt.savefig(f"img/cm_vader.png", bbox_inches='tight')

# Exibir o gráfico
plt.show()

Essa abordagem é boa para ser utilizada como baseline pois quase todas as abordagens tradicionais de Machine Learning para a tarefa de análise de sentimentos necessitam de tempo para desenvolvimento, treino, validação e sustentação de modelos.