Google Bard para projetos de ciência de dados

A versão mais recente do Bard, baseada no modelo PaLM 2, traz ganhos em raciocínio, código e suporte multilíngue. Diferente do ChatGPT, você precisa adaptar melhor sua entrada para o Bard a fim de obter respostas de alta qualidade.

Neste post, vamos ver como aproveitar o novo Bard para construir um projeto de ciência de dados de ponta a ponta. Você vai aprender a criar prompts eficazes que geram ideias e código para experimentação e desenvolvimento.

Leia nosso artigo Bard vs ChatGPT para ciência de dados para uma comparação detalhada entre o Google Bard e o ChatGPT, nosso artigo geral ChatGPT vs Google Bard e confira também o tutorial ChatGPT para projetos de ciência de dados como outra opção.

Planejamento do projeto

A fase de planejamento é crucial em qualquer projeto, pois define as bases do sucesso. Nela, analisamos com cuidado os recursos e objetivos disponíveis e desenhamos um plano com as etapas necessárias para alcançar as metas.

Para criar um esqueleto do projeto, vamos escrever um prompt detalhado para o Bard com todas as informações relevantes sobre o desenvolvimento do nosso aplicativo de detecção de fake news. Ele trará pontos-chave como o dataset que usaremos — o Fake News Classification, do artigo WELFake — e diretrizes que vão orientar o time durante todo o desenvolvimento.

Prompt: “Aja como um Data Science Manager e desenvolva planos para um projeto de detecção de fake news de ponta a ponta. Já temos o dataset FakeNewsDetection com 72.134 linhas e 4 colunas: [Unnamed: 0, title, text e label (0 = fake e 1 = real)].”

Embora o plano genérico seja um bom ponto de partida, faltam algumas etapas críticas. Podemos incluir o que falta com um prompt de acompanhamento.

Prompt de acompanhamento: “Inclua etapas como EDA, seleção de modelo, otimização de hiperparâmetros, webapp em Streamlit e deploy no Streamlit Cloud. Forneça um plano de projeto unificado.”

Parece que o Bard não percebeu que já temos um dataset e não precisamos da etapa de coleta de dados. Você pode escrever um prompt de acompanhamento para ajustar isso.

Prompt de acompanhamento: “Já temos os dados, então remova a etapa de coleta de dados do plano de projeto.”

Aqui está o esboço do projeto de detecção de fake news:

1. Pré-processamento de dados
2. Análise exploratória de dados (EDA)
3. Extração de atributos
4. Seleção de modelo
5. Otimização de hiperparâmetros
6. Treinamento e avaliação do modelo
7. Webapp em Streamlit
8. Deploy no Streamlit Cloud

O plano detalha cada etapa para construir nosso aplicativo de detecção de fake news, além de metodologias recomendadas para otimizar os resultados. Também traz uma agenda semanal com tarefas e marcos.

Se estiver com dificuldade para escrever prompts ou se sentindo sobrecarregado, calma que te ajudamos. Baixe nossa Prompt Engineering Cheat Sheet, com mais de 60 prompts elaborados por especialistas para diferentes tarefas de ciência de dados.

Bard para pré-processamento de dados

Nesta etapa, vamos carregar, limpar e fazer engenharia de atributos no dataset.

Carregamento de dados

Agora troque o “personagem” de Data Manager para Data Scientist e escreva um prompt para carregar os dados.

Prompt: “Aja como um Data Scientist profissional e escreva um código em Python para carregar cinco mil amostras aleatórias do dataset para o projeto acima.”

Observação: estamos reduzindo a amostra para treinar e ajustar os modelos mais rápido.

import pandas as pd

# Load the dataset
df = pd.read_csv("fake-news-classification/WELFake_Dataset.csv")

# Get 5 thousand random samples
df = df.sample(n=5000, random_state=42)

# Print the first 5 rows of the data
df.head()

Limpeza de dados

Para garantir que o dataset esteja bem limpo e pronto para análise, vamos dar instruções específicas ao Bard sobre as funções necessárias de limpeza.

Prompt: “Agora, escreva uma função em Python para limpar o dataset. A função deve remover valores ausentes, excluir a coluna \"Unnamed: 0\", limpar o texto e remover stopwords.”

Se aparecerem bugs ou erros, vamos pedir ao Bard para corrigir o erro de stopwords. Ele entende o problema e gera uma versão melhor do código.

Prompt atualizado: “Corrija o erro com stopwords”

import nltk
nltk.download('stopwords')

from nltk.corpus import stopwords

def clean_dataset(df):

  # Drop missing values
  df = df.dropna()
    
  # Drop Unnamed column
  df = df.drop(["Unnamed: 0"], axis=1)

  # Clean text
  df['text'] = df['text'].str.lower()
  df["Text"] = df["Text"].str.replace("[^a-zA-Z]", " ")

  # Remove stopwords
  stopword = set(stopwords.words('english'))
  df['text'] = df['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in stopword]))

  return df

df = clean_dataset(df)
df.head()

Temos um dataset bem limpo.

Engenharia de atributos

Para o Bard gerar código melhor, vale ser específico nas instruções, e não fazer perguntas genéricas. Por exemplo, se pedirmos “combine o tamanho das duas colunas de texto”, ele tende a produzir um código mais adequado ao projeto.

Prompt: “Agora, escreva uma função em Python para fazer engenharia de atributos. Coloque a coluna title em minúsculas e combine text e title, calcule o comprimento combinado das colunas de texto, conte palavras únicas e mais.”

def feature_engineering(df):

  # Lower the title column
  df['title'] = df['title'].str.lower()

  # Combine text and title
  df['combined'] = df['title'] + ' ' + df['text']

  # Length of the combined text
  df['combined_length'] = df['combined'].str.len()

  # Count unique words
  df['unique_words'] = df['text'].apply(lambda x: len(set(x.split())))

  return df

# Perform feature engineering
df = feature_engineering(df)

# Print the first few rows of the DataFrame with the new features
df.head()

Criamos três novos atributos que usaremos na análise.

Bard para análise exploratória de dados (EDA)

Na parte de EDA, vamos pedir ao Bard alguns gráficos importantes para explorar os dados.

Prompt: “Escreva código em Python para realizar a análise exploratória de dados (EDA) no projeto acima. Inclua um histograma com o comprimento combinado de fake vs. real, distribuição de rótulos e nuvem de palavras.”

Vamos escrever um prompt de acompanhamento para adicionar limites de bins.

Prompt de acompanhamento: “Atualize o código de EDA com `np.linspace` para criar bins de 0 a 200 com largura de 40.”

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

bins = np.linspace(0, 200, 40)
# Histogram of the length of fake vs real news articles
plt.hist(df['combined_length'].where(df['label'] == 1),bins, alpha=0.5, label='Real')
plt.hist(df['combined_length'].where(df['label'] == 0),bins, alpha=0.5, label='Fake')
plt.xlabel('Combined Text Length')
plt.ylabel('Number of Articles')
plt.legend()
plt.show()

Parece que as fake news têm textos mais longos do que as notícias reais.

# Label distribution
plt.pie(df['label'].value_counts(), labels=['Fake', 'Real'], autopct='%1.1f%%')
plt.show()

A distribuição dos rótulos é bem equilibrada, então não precisamos balancear classes.

from wordcloud import WordCloud

wc = WordCloud(max_words=100, background_color='white')
wc.generate(' '.join(df[df['label'] == 0]['combined']))
plt.imshow(wc)
plt.axis('off')
plt.title('Word cloud of fake news articles')
plt.show()

wc = WordCloud(max_words=100, background_color='white')
wc.generate(' '.join(df[df['label'] == 1]['combined']))
plt.imshow(wc)
plt.axis('off')
plt.title('Word cloud of real news articles')
plt.show()

Nas notícias reais, aparecem mais termos de destaque como “trump” e “said” em comparação às fake news.

Extração de atributos com o Bard

Aqui, vamos escrever um prompt para converter a coluna “text” em vetores e dividir o dataset em treino e teste.

Prompt: “Converta a coluna de texto em vetores e divida o dataset em conjuntos de treino e teste.”

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split

# Convert the text column into vectors
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(df['text'])

# Split the dataset into training and testing datasets
X_train, X_test, y_train, y_test = train_test_split(X, df['label'], test_size=0.25)

Bard para seleção de modelo

Com o contexto preparado, você pode fazer perguntas diretas.

Prompt: “Realize a seleção de modelo.”

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Train the models
models = [LogisticRegression(), SVC(), DecisionTreeClassifier(), RandomForestClassifier()]
for model in models:
    model.fit(X_train, y_train)

# Evaluate the models
predictions = []
for model in models:
    predictions.append(model.predict(X_test))

# Calculate the accuracy of the models
accuracies = []
for predictions in predictions:
    accuracies.append(accuracy_score(y_test, predictions))

# Print the accuracy of the models
print("Accuracy of LogisticRegression:", accuracies[0])
print("Accuracy of SVC:", accuracies[1])
print("Accuracy of DecisionTreeClassifier:", accuracies[2])
print("Accuracy of RandomForestClassifier:", accuracies[3])

Accuracy of LogisticRegression: 0.9024979854955681
Accuracy of SVC: 0.91941982272361
Accuracy of DecisionTreeClassifier: 0.8767123287671232
Accuracy of RandomForestClassifier: 0.8863819500402901

Pelo nosso teste, todos os modelos foram bem, mas o Support Vector Classifier (SVC) teve a maior acurácia.

Ajuste de hiperparâmetros com o Bard

Pedimos ao Bard um código de otimização de hiperparâmetros que também salve o melhor modelo e o objeto de vetorização para o deploy.

Prompt: ”Escreva um código em Python para otimização de hiperparâmetros do SVC. Também salve o melhor modelo e o vectorizer usando Joblib.”

from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score,f1_score, classification_report, confusion_matrix

import joblib

# Create a RandomForestClassifier model
svm = SVC()

# Create the hyperparameter grid
param_grid = {'C': [1, 10, 100], 'gamma': [0.01, 0.1, 1]}

# Create the GridSearchCV object
grid = GridSearchCV(SVC(), param_grid, cv=5)


# Fit the GridSearchCV object to the training data
grid.fit(X_train, y_train)

# Print the best parameters
print(grid.best_params_)

{'C': 10, 'gamma': 0.1}

# Predict the labels of the testing data using the best model
y_pred = grid.predict(X_test)

# Calculate the accuracy of the best model
accuracy = accuracy_score(y_test, y_pred)

# Print the accuracy of the best model
print("Accuracy of the best model:", accuracy)

A acurácia melhorou um pouco.

Accuracy of the best model: 0.9298952457695407

O modelo e o vetor salvos serão usados na inferência.

# Save the best model
joblib.dump(grid.best_estimator_, 'best_model.pkl')
# Save the TfidfVectorizer
joblib.dump(vectorizer, 'tfidf_vectorizer.pkl')

Avaliação do modelo com o Bard

Acurácia sozinha não basta em classificação. Precisamos avaliar f1-score, recall, precisão e a matriz de confusão.

Prompt: ”Escreva um código em Python para avaliação do modelo. Inclua classification report, confusion matrix e f1-score.”

print(classification_report(y_test, y_pred))

Pelo relatório, nosso modelo está bem estável no conjunto de teste.

              precision    recall  f1-score   support

           0       0.94      0.92      0.93       620
           1       0.92      0.94      0.93       621

    accuracy                           0.93      1241
   macro avg       0.93      0.93      0.93      1241
weighted avg       0.93      0.93      0.93      1241

# Plot the confusion matrix
print(confusion_matrix(y_test, y_pred))

[[572  65]
 [ 37 567]]

# Calculate the F1 score
f1_score = f1_score(y_test, y_pred, average='weighted')

# Print the F1 score
print("F1 score:", f1_score)

F1 score: 0.9298892365447746

Usando o Bard para um webapp em Streamlit

Com os resultados em mãos, vamos criar um app que converte o texto de entrada em vetor, passa pelo modelo e exibe o resultado.

Antes, precisamos criar um repositório no GitHub.

Clone o repositório e salve todos os componentes essenciais do app. Isso garante segurança e permite versionar tanto o app quanto o modelo.

git clone https://github.com/kingabzpro/Fake-News-DataCamp-Project.git

Escreva um prompt genérico para criar um app que prevê se a notícia é real ou fake.

Prompt: “Escreva um arquivo Python separado para criar um web app com Streamlit que prevê se a notícia é (0 = fake ou 1 = real). Inclua apenas a parte do app em Streamlit.”

Depois, crie o arquivo app.py e cole o código do Bard nele. Em seguida, rode a aplicação com streamlit run app.py.

Observação: verifique se você tem todos os pacotes Python necessários para executar o app em Streamlit.

Parece que o Bard não carregou o vectorizer. Podemos escrever um prompt de acompanhamento para corrigir isso.

Prompt de acompanhamento: “Adicione o carregamento do Vectorizer e do Model no arquivo do app usando joblib.”

O app não está funcionando direito, então vamos adicionar um botão de execução para resolver.

Prompt de acompanhamento: “Também adicione um botão para rodar a inferência.”

import streamlit as st
import joblib

# Load the vectorizer
vectorizer = joblib.load("tfidf_vectorizer.pkl")

# Load the model
model = joblib.load("best_model.pkl")

# Create a title
st.title("Predict Fake News")

# Input text
text = st.text_input("Enter the news article:")

# Button to run inference
if st.button("Predict"):

    # Convert the text to a vector
    vector = vectorizer.transform([text])

    # Predict the label
    label = model.predict(vector)[0]

    # Display the label
    if label == 0:
        st.write("The news article is fake.")
    else:
        st.write("The news article is real.")

Conseguimos criar um app em Streamlit que recebe texto e prevê a autenticidade da notícia.

Usando o Bard para deploy no Streamlit Cloud

Para publicar o app na nuvem, vamos pedir ajuda ao Bard. No fim, basta enviar o código ao GitHub e conectar ao servidor do Streamlit.

Prompt: “Ajude-me a fazer o deploy de um app no Streamlit Community Cloud.”

1. Crie um arquivo requirements.txt e inclua todos os pacotes necessários, como “scikit-learn”.

2. Adicione os arquivos com Git, faça commit e push para o servidor. Garanta que você incluiu o modelo, o vetor, o app.py e o requirements.txt.

3. Acesse share.streamlit.io, clique em “New app”, selecione o repositório do GitHub e informe os dados do aplicativo.

Pronto. Nosso app está no ar e disponível ao público no Streamlit (fake-news-detector.streamlit.app).

Conclusão

Ferramentas de IA como ChatGPT, Bard e Claude ajudam você a mandar bem nas tarefas do dia a dia em ciência de dados. Ao aproveitar essas capacidades, ganhamos eficiência e elevamos a qualidade do trabalho, enfrentando desafios complexos com mais tranquilidade.

Neste post, exploramos o potencial da nova versão do Bard para criar projetos completos de ciência de dados de ponta a ponta. Você também pode conferir nosso guia sobre como usar o ChatGPT em projetos de ciência de dados ou fazer um curso completo de ChatGPT: Introduction to ChatGPT, e descobrir as melhores práticas para escrever prompts.