Google Bard per progetti di data science

L’ultima versione di Bard, basata sul modello PaLM 2, offre prestazioni migliorate in ragionamento, coding e capacità multilingue. A differenza di ChatGPT, per ottenere risposte di alta qualità gli utenti devono adattare il proprio input allo stile di Bard.

Questo post spiega come sfruttare il nuovo Bard per costruire un progetto di data science end-to-end. Imparerai a creare prompt efficaci che generano idee e codice per esperimenti e sviluppo.

Leggi il nostro articolo Bard vs ChatGPT per la data science per un confronto dettagliato tra Google Bard e ChatGPT, il nostro articolo generale ChatGPT vs Google Bard e dai un’occhiata anche al tutorial ChatGPT per progetti di data science come alternativa.

Pianificazione del progetto

La fase di pianificazione è un passaggio cruciale in ogni progetto, perché getta le basi per il successo. In questa fase analizziamo con attenzione risorse e obiettivi disponibili e sviluppiamo un piano che definisce i passi necessari per raggiungere i nostri scopi.

Per creare una traccia del progetto, scriveremo un prompt dettagliato per Bard che includa tutte le informazioni rilevanti sullo sviluppo della nostra applicazione di Fake News Detection. Includerà dettagli chiave, come il dataset che useremo, ossia il dataset Fake News Classification dell’articolo WELFake, oltre a eventuali direttive di progetto che guideranno il team durante lo sviluppo.

Prompt: “Agisci come Data Science Manager e sviluppa i piani per un progetto end-to-end di Fake News Detection. Abbiamo già il dataset FakeNewsDetection composto da 72.134 righe e 4 colonne: [Unnamed: 0, title, text e label (0 = fake e 1 = real)].”

Anche se la traccia generica del progetto fornisce una base solida, mancano alcuni passaggi fondamentali. Possiamo aggiungere i passaggi necessari scrivendo un prompt di follow-up.

Prompt di follow-up: “Aggiungi passaggi come EDA, selezione del modello, ottimizzazione degli iperparametri, web app Streamlit e deployment su Streamlit Cloud. Fornisci un piano di progetto combinato.”

Sembra che Bard non stia comprendendo che abbiamo già un dataset e non ci serve la parte di raccolta dati. Puoi scrivere un prompt di follow-up per rifinire i bordi.

Prompt di follow-up: “Abbiamo già i dati, quindi rimuovi la fase di Data collection dal piano di progetto.”

Ecco la traccia per il progetto di Fake News Detection:

1. Preprocessing dei dati
2. Analisi esplorativa dei dati (EDA)
3. Estrazione delle feature
4. Selezione del modello
5. Ottimizzazione degli iperparametri
6. Addestramento e valutazione del modello
7. Web app con Streamlit
8. Deployment su Streamlit Cloud

Il piano di progetto include una spiegazione dettagliata di ogni passaggio per costruire la nostra applicazione di Fake News Detection, oltre a metodologie consigliate per ottimizzare i risultati. Inoltre, il piano fornisce un’agenda settimanale con attività chiave e milestone.

Se fai fatica a scrivere prompt o ti senti sopraffatto, ci pensiamo noi. Scarica la nostra Prompt Engineering Cheat Sheet, che ti dà accesso a una raccolta di oltre 60 prompt realizzati da esperti per vari compiti di data science.

Bard per il preprocessing dei dati

In questo passaggio caricheremo, puliremo ed eseguiremo ingegnerizzazione delle feature sul dataset.

Caricamento dei dati

Ora devi cambiare ruolo da Data Manager a Data Scientist per scrivere un prompt per il caricamento dei dati.

Prompt: “Agisci come un Data Scientist professionista e scrivi un codice Python per caricare cinquemila campioni casuali dal dataset per il progetto sopra.”

Nota: stiamo effettuando un downsampling dei dati per addestrare e ottimizzare i modelli più velocemente.

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()

Pulizia dei dati

Per garantire che il nostro dataset sia pulito e pronto per l’analisi, forniremo a Bard istruzioni specifiche sulle funzioni di data cleaning necessarie.

Prompt: “Ora, scrivi una funzione Python per pulire il dataset. La funzione deve eliminare i valori mancanti, rimuovere la colonna "Unnamed: 0", pulire il testo e rimuovere le stopword.”

Per risolvere eventuali bug o errori nel nostro codice, chiederemo a Bard di correggere l’errore sulle stopword. Capirà l’errore e genererà una versione migliorata del codice.

Prompt aggiornato: “Risolvi l’errore con le stopword”

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()

Abbiamo un dataset abbastanza pulito.

Ingegnerizzazione delle feature

Per fare in modo che Bard generi codice ottimale, è importante fornire istruzioni specifiche, non domande generiche. Ad esempio, se chiediamo a Bard di eseguire una funzione specifica, come “combina la lunghezza di entrambe le colonne di testo”, sarà in grado di generare codice di qualità migliore, su misura per le esigenze del nostro progetto.

Prompt: “Ora, scrivi una funzione Python per eseguire l’ingegnerizzazione delle feature. Metti in minuscolo la colonna title e combina text e title, combina la lunghezza di entrambe le colonne di testo, conta le parole uniche e altro.”

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()

Abbiamo creato tre nuove feature che useremo per l’analisi dei dati.

Bard per l’analisi esplorativa dei dati (EDA)

Nella parte EDA chiederemo a Bard di creare alcune visualizzazioni importanti per l’esplorazione dei dati.

Prompt: “Scrivi codice Python per eseguire l’analisi esplorativa dei dati (EDA) sul progetto sopra. Includi un istogramma per confrontare la lunghezza del testo tra fake e real, la distribuzione delle etichette e una word cloud.”

Scriveremo un prompt di follow-up per aggiungere i bordi dei bin.

Prompt di follow-up: “Aggiorna il codice EDA con `np.linspace` per creare bin edge da 0 a 200 con ampiezza del bin 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()

Sembra che le fake news abbiano una lunghezza del testo maggiore rispetto alle real news.

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

La distribuzione delle etichette è abbastanza equilibrata e non dobbiamo eseguire un bilanciamento delle classi.

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()

Le real news hanno parole più prominenti come “trump” e “said” rispetto alle fake news.

Estrazione delle feature con Bard

In questa parte scriveremo un prompt per convertire una colonna “text” in vettori e dividere il dataset in train e test.

Prompt: “Converti la colonna text in vettori e dividi il dataset in training e testing set.”

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 per la selezione del modello

Con le informazioni necessarie fornite, ora puoi fare domande dirette.

Prompt: “Esegui la selezione del modello.”

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

In base alla nostra analisi, tutti i modelli testati si sono comportati piuttosto bene. Tuttavia, il modello Support Vector Classifier (SVC) ha ottenuto l’accuratezza più alta tra quelli provati.

Ottimizzazione degli iperparametri con Bard

Abbiamo chiesto a Bard di scrivere un codice per l’ottimizzazione degli iperparametri che salvi il modello e l’oggetto vettorizzatore ottimali per il deployment.

Prompt: ”Scrivi un codice Python per l’ottimizzazione degli iperparametri di SVC. Inoltre, salva il miglior modello e il vettorizzatore 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)

L’accuratezza è migliorata leggermente.

Accuracy of the best model: 0.9298952457695407

Il modello e il vettorizzatore salvati verranno utilizzati per eseguire l’inferenza.

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

Valutazione del modello con Bard

L’accuratezza non basta per un modello di classificazione. Dobbiamo testarlo anche su f1-score, recall, precision e matrice di confusione.

Prompt: ”Scrivi un codice Python per la valutazione del modello. Includi classification report, confusion matrix e f1 score.”

print(classification_report(y_test, y_pred))

Secondo il report, il nostro modello è abbastanza stabile sul dataset di test.

              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

Usare Bard per una web app Streamlit

Dopo aver ottenuto risultati soddisfacenti, svilupperemo un’app che convertirà il testo di input in un vettore, lo passerà a un modello e mostrerà il risultato.

Prima di questo, dobbiamo creare un repository GitHub.

Clona il repository e salva tutti i componenti essenziali dell’applicazione. Questo passaggio ne garantisce la sicurezza e abilita anche un versionamento efficace sia dell’app che del modello.

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

Scrivi un prompt generico per sviluppare un’app che predica se una notizia è reale o falsa.

Prompt: “Scrivi un file Python separato per creare una web app con Streamlit per prevedere se la notizia è (0 = fake o 1 = real). Includi solo la parte dell’app Streamlit.”

Poi crea un file app.py e copia il codice da Bard in questo file. Fatto ciò, puoi eseguire l’applicazione con il comando streamlit run app.py.

Nota: assicurati di avere tutti i pacchetti Python richiesti per eseguire l’app Streamlit.

Sembra che Bard non sia riuscito a caricare il vettorizzatore. Possiamo scrivere un prompt di follow-up per risolvere il problema.

Prompt di follow-up: “Aggiungi il caricamento del Vectorizer e del Model nel file dell’app usando joblib.”

L’app non funziona correttamente, quindi dobbiamo aggiungere un pulsante di esecuzione per risolvere il problema.

Prompt di follow-up: “Aggiungi anche un pulsante per eseguire l’inferenza.”

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.")

Abbiamo creato con successo una app Streamlit che accetta testo in input e fornisce previsioni sull’autenticità degli articoli di news.

Usare Bard per il deployment su Streamlit Cloud

Per pubblicare l’app nel cloud, dobbiamo chiedere aiuto a Bard. A quanto pare ci basta pushare il codice sul repository GitHub e collegarlo al server Streamlit.

Prompt: “Aiutami a fare il deployment di un’app su Streamlit Community Cloud.”

1. Crea un file requirements.txt e aggiungi tutti i pacchetti Python necessari come “scikit-learn”.

2. Aggiungi i file con Git, fai commit e push sul server esterno. Assicurati di aver aggiunto modello, vettore, app.py e requirements.txt.

3. Vai su share.streamlit.io, clicca su “New app”, seleziona il repository GitHub e aggiungi le informazioni richieste sull’applicazione.

È tutto. La nostra app è distribuita e disponibile al pubblico su Streamlit (fake-news-detector.streamlit.app).

Conclusione

Strumenti di AI come ChatGPT, Bard e Claude ci permettono di eccellere nelle attività quotidiane di data science. Sfruttandone le capacità, aumentiamo efficienza e competenza, affrontando con facilità sfide complesse sui dati.

In questo post abbiamo esplorato la potenza della nuova versione di Bard per sviluppare progetti di data science end-to-end. Puoi anche consultare la nostra guida su Usare ChatGPT per progetti di data science o seguire un corso completo su ChatGPT: Introduzione a ChatGPT, e scoprire le best practice per scrivere prompt.