Google Bard voor data-scienceprojecten

De nieuwste versie van Bard, aangedreven door het PaLM 2-model, biedt betere prestaties in redeneren, coderen en meertaligheid. In tegenstelling tot ChatGPT moeten gebruikers hun input afstemmen op Bard om reacties van hoge kwaliteit te krijgen.

Deze post laat zien hoe je de nieuwe Bard inzet om een end-to-end data-scienceproject te bouwen. Je leert effectieve prompts te schrijven die ideeën en code genereren voor experimenten en ontwikkeling.

Lees ons artikel Bard vs ChatGPT voor Data Science voor een gedetailleerde vergelijking tussen Google Bard en ChatGPT, ons algemene artikel ChatGPT vs Google Bard, en bekijk onze tutorial ChatGPT voor data-scienceprojecten voor een ander alternatief.

Projectplanning

De planningsfase is cruciaal in elk project, omdat die de basis legt voor succes. In deze fase analyseren we zorgvuldig de beschikbare middelen en doelstellingen en ontwikkelen we een projectplan met de stappen die nodig zijn om onze doelen te bereiken.

Om een projectoverzicht te maken, schrijven we een gedetailleerde prompt voor Bard met alle relevante informatie over de ontwikkeling van onze Fake News Detection-applicatie. Die bevat belangrijke details, zoals de dataset die we gebruiken, namelijk de Fake News Classification-dataset uit de WELFake-paper, en projectrichtlijnen die ons team door het ontwikkelproces leiden.

Prompt: “Doe alsof je Data Science Manager bent en ontwikkel plannen voor een end-to-end Fake News Detection-project. We hebben al de FakeNewsDetection dataset met 72.134 rijen en 4 kolommen: [Unnamed: 0, title, text en ;abel (0 = fake en 1 = real)].”

Hoewel het generieke projectoverzicht een solide basis biedt, ontbreken er een paar cruciale stappen. We kunnen de benodigde stappen toevoegen met een vervolg-prompt.

Vervolgprompt: “Voeg stappen toe zoals EDA, modelselectie, hyperparameteroptimalisatie, Streamlit-webapp en Streamlit Cloud-deployment. Geef een gecombineerd projectplan.”

Het lijkt erop dat Bard niet begrijpt dat we al een dataset hebben en het onderdeel dataverzameling niet nodig is. Je kunt een vervolgprompt schrijven om dat te stroomlijnen.

Vervolgprompt: “We hebben al data, dus verwijder de stap Dataverzameling uit het projectplan.”

Hier is het overzicht voor het Fake News Detection-project:

1. Datapreprocessing
2. Exploratory data analysis (EDA)
3. Feature-extractie
4. Modelselectie
5. Hyperparameteroptimalisatie
6. Modeltraining en -evaluatie
7. Streamlit-webapp
8. Streamlit Cloud-deployment

Het projectplan bevat een gedetailleerde uitleg van elke stap voor het bouwen van onze Fake News Detection-applicatie, plus aanbevolen methodologieën om onze resultaten te optimaliseren. Daarnaast biedt het plan een weekagenda met kerntaken en mijlpalen.

Vind je het lastig om prompts te schrijven of voel je je overweldigd? Geen zorgen. Download onze Prompt Engineering Cheat Sheet met meer dan 60 zorgvuldig opgestelde prompts voor uiteenlopende data-sciencetaken.

Bard voor datapreprocessing

In deze stap laden we de dataset, maken we die schoon en doen we feature-engineering.

Data laden

Nu moet je van rol veranderen, van Data Manager naar Data Scientist, om een prompt te schrijven voor het laden van de data.

Prompt: “Doe alsof je een professionele Data Scientist bent en schrijf Python-code om vijfduizend willekeurige samples uit de dataset te laden voor bovenstaand project.”

Let op: we downsamplen de data om de modellen sneller te trainen en te optimaliseren.

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

Data opschonen

Om ervoor te zorgen dat onze dataset goed is opgeschoond en klaar voor analyse, geven we Bard specifieke instructies over de benodigde opschoningsfuncties.

Prompt: “Schrijf nu een Python-functie om de dataset op te schonen. De functie moet missende waarden droppen, de kolom "Unnamed: 0" verwijderen, tekst opschonen en stopwoorden verwijderen.”

Om eventuele bugs of fouten in onze code aan te pakken, vragen we Bard om de stopwoordenfout op te lossen. Bard begrijpt de vergissing en genereert een verbeterde versie van de code.

Bijgewerkte prompt: “Los de fout met stopwoorden op”

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

We hebben nu een behoorlijk schone dataset.

Feature-engineering

Om te zorgen dat Bard optimale code genereert, is het belangrijk om specifieke instructies te geven in plaats van algemene vragen. Als we Bard bijvoorbeeld vragen om een specifieke functie, zoals “combineer de lengte van beide tekstkolommen”, dan krijg je betere, projectspecifieke code.

Prompt: “Schrijf nu een Python-functie voor feature-engineering. Maak de title-kolom lowercase en combineer text en title, combineer de lengte van beide tekstkolommen, tel unieke woorden, en meer.”

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

We hebben drie nieuwe features gemaakt die we gebruiken voor data-analyse.

Bard voor Exploratory Data Analysis (EDA)

In het EDA-gedeelte vragen we Bard om bepaalde visualisaties te maken die belangrijk zijn voor de verkenning van de data.

Prompt: “Schrijf Python-code om Exploratory Data Analysis (EDA) uit te voeren op het bovenstaande project. Voeg een histogram toe om de lengte van fake vs real te vergelijken, labelverdeling en een wordcloud.”

We schrijven een vervolgprompt om binedges toe te voegen.

Vervolgprompt: “Werk de EDA-code bij met `np.linspace` om binedges van 0 tot 200 met 40 binbreedte te maken.”

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

Het lijkt erop dat nepnieuws een langere tekstlengte heeft dan echt nieuws.

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

De labelverdeling is vrij gelijk, dus we hoeven geen class balancing toe te passen.

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

In echt nieuws komen woorden als “trump” en “said” prominenter voor dan in nepnieuws.

Feature-extractie met Bard

In dit deel schrijven we een prompt om een “text”-kolom om te zetten in vectoren en de dataset te splitsen in train- en testsets.

Prompt: “Zet de text-kolom om in vectoren en splits de dataset in trainings- en testdatasets.”

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 voor modelselectie

Met de nodige achtergrondinformatie kun je nu rechttoe rechtaan vragen stellen.

Prompt: “Voer modelselectie uit.”

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

Op basis van onze analyse lijken alle geteste modellen het redelijk goed te doen. De Support Vector Classifier (SVC) behaalde echter de hoogste nauwkeurigheid van de geteste modellen.

Hyperparameter-tuning met Bard

We hebben Bard gevraagd om code voor hyperparameter-tuning te schrijven die het optimale model en het vectorobject opslaat voor deployment.

Prompt: ”Schrijf Python-code voor hyperparameteroptimalisatie van SVC. Sla ook het beste model en de vectorizer op met 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)

De nauwkeurigheid is licht verbeterd.

Accuracy of the best model: 0.9298952457695407

De opgeslagen modus en vector worden gebruikt om de inferentie uit te voeren.

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

Model-evaluatie met Bard

Nauwkeurigheid alleen is niet genoeg voor een classificatiemodel. We moeten het ook testen op f1-score, recall, precision en de confusion matrix.

Prompt: ”Schrijf Python-code voor modelevaluatie. Neem het classificatierapport, de confusion matrix en de f1-score op.”

print(classification_report(y_test, y_pred))

Volgens het rapport is ons model behoorlijk stabiel op de testdataset.

              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

Bard gebruiken voor een Streamlit-webapp

Als we tevreden zijn met het resultaat, bouwen we een app die de invoertekst omzet naar een vector, die door een model haalt en het resultaat toont.

Daarvoor moeten we eerst een GitHub-repository maken.

Kloon de repository en sla alle essentiële onderdelen van de applicatie op. Deze stap zorgt niet alleen voor veilige opslag, maar maakt ook effectieve versiebeheer van zowel de app als het model mogelijk.

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

Schrijf een generieke prompt om een app te ontwikkelen die voorspelt of nieuws echt of nep is.

Prompt: “Schrijf een apart Python-bestand om met Streamlit een webapp te maken die voorspelt of het nieuws (0 = fake of 1 = real) is. Neem alleen het Streamlit-appgedeelte op.”

Maak daarna een app.py -bestand en zet de code van Bard hierin. Als dat klaar is, kun je de app starten met het commando streamlit run app.py.

Let op: zorg dat je alle vereiste Python-pakketten hebt om de Streamlit-app te draaien.

Het lijkt erop dat Bard de vectorizer niet heeft geladen. We schrijven een vervolgprompt om dit op te lossen.

Vervolgprompt: “Voeg het laden van de Vectorizer en het Model toe in het app-bestand met joblib.”

De app werkt niet goed, dus we moeten een run-knop toevoegen om dat te verhelpen.

Vervolgprompt: “Voeg ook een knop toe om de inferentie uit te voeren.”

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

We hebben met succes een Streamlit-app gebouwd die tekstinvoer accepteert en voorspellingen geeft over de authenticiteit van nieuwsartikelen.

Bard gebruiken voor Streamlit Cloud-deployment

Om de app in de cloud te deployen, vragen we Bard om hulp. Het blijkt dat we alleen onze code naar de GitHub-repository hoeven te pushen en die te koppelen aan de Streamlit-server.

Prompt: “Help me een app te deployen op Streamlit Community Cloud.”

1. Maak een requirements.txt-bestand en voeg alle vereiste Python-pakketten toe, zoals “scikit-learn”.

2. Voeg de bestanden toe met Git, commit en push naar de externe server. Zorg dat je het model, de vector, app.py en requirements.txt hebt toegevoegd.

3. Ga naar share.streamlit.io, klik op “New app”, selecteer de GitHub-repository en voeg de vereiste informatie over de applicatie toe.

Dat is alles. Onze app is gedeployed en openbaar beschikbaar op Streamlit (fake-news-detector.streamlit.app).

Conclusie

AI-tools zoals ChatGPT, Bard en Claude helpen ons excelleren in onze dagelijkse data-sciencetaken. Door deze tools te benutten, vergroten we onze efficiëntie en slagkracht, zodat we complexe data-uitdagingen met gemak aankunnen.

In deze post hebben we de kracht van de nieuwe versie van Bard verkend voor het ontwikkelen van complete end-to-end data-scienceprojecten. Bekijk ook onze gids ChatGPT gebruiken voor data-scienceprojecten of volg een uitgebreide ChatGPT-cursus: Introduction to ChatGPT, en ontdek best practices voor het schrijven van prompts.