Die neueste Version von Bard, angetrieben vom PaLM 2-Modell, bietet bessere Leistungen beim Schlussfolgern, Codieren und in mehreren Sprachen. Anders als bei ChatGPT musst du deine Eingaben gezielt auf Bard zuschneiden, um hochwertige Antworten zu erhalten.
In diesem Beitrag zeigen wir, wie du das neue Bard nutzt, um ein End-to-End-Data-Science-Projekt aufzubauen. Du lernst, wirkungsvolle Prompts zu formulieren, die Ideen und Code für Experimente und Entwicklung liefern.
Lies auch unseren Artikel Bard vs. ChatGPT für Data Science für einen detailierten Vergleich zwischen Google Bard und ChatGPT, unseren allgemeinen Beitrag ChatGPT vs. Google Bard sowie unser Tutorial ChatGPT für Data-Science-Projekte als weitere Option.
Projektplanung
Die Planungsphase ist in jedem Projekt ein entscheidender Schritt, denn sie legt das Fundament für den Erfolg. In dieser Phase analysieren wir sorgfältig die verfügbaren Ressourcen und Ziele und entwickeln einen Projektplan, der die notwendigen Schritte zur Zielerreichung festhält.
Für die Projektstruktur erstellen wir einen detaillierten Prompt für Bard, der alle relevanten Informationen zur Entwicklung unserer Fake-News-Detection-App enthält. Dazu gehören Schlüsseldaten wie das verwendete Dataset, nämlich das Fake News Classification-Dataset aus der WELFake-Publikation, sowie Projektvorgaben, die uns durch die Entwicklung leiten.
Prompt: „Handle als Data-Science-Manager und entwickle Pläne für ein End-to-End-Projekt zur Erkennung von Fake News. Wir haben bereits das FakeNewsDetection-Dataset mit 72.134 Zeilen und 4 Spalten: [Unnamed: 0, title, text und label (0 = fake, 1 = real)].“
Der generische Projektüberblick ist eine gute Grundlage, allerdings fehlen ein paar wichtige Schritte. Diese fügen wir mit einem kurzen Folge-Prompt hinzu.
Follow-up-Prompt: „Bitte füge Schritte wie EDA, Modellauswahl, Hyperparameteroptimierung, Streamlit-Webapp und Deployment auf Streamlit Cloud hinzu. Liefere einen kombinierten Projektplan.“
Es wirkt so, als hätte Bard nicht verstanden, dass wir das Dataset bereits haben und keine Datensammlung benötigen. Mit einem weiteren Prompt schärfen wir nach.
Follow-up-Prompt: „Wir haben die Daten bereits, entferne den Schritt zur Datensammlung aus dem Projektplan.“
Hier ist die Struktur für das Fake-News-Detection-Projekt:
- Datenvorverarbeitung
- Explorative Datenanalyse (EDA)
- Feature-Extraktion
- Modellauswahl
- Hyperparameteroptimierung
- Modelltraining und -bewertung
- Streamlit-Webapp
- Deployment auf Streamlit Cloud
Der Projektplan enthält eine ausführliche Erklärung zu jedem Schritt beim Aufbau unserer Fake-News-Detection-App sowie empfohlene Methoden, um die Ergebnisse zu optimieren. Zusätzlich liefert er eine Wochenagenda mit Kernaufgaben und Meilensteinen.
Wenn dir das Schreiben von Prompts schwerfällt oder du dich überfordert fühlst, haben wir etwas für dich. Lade dir unser Prompt-Engineering-Cheatsheet herunter – darin findest du über 60 erstklassig formulierte Prompts für verschiedenste Data-Science-Aufgaben.
Bard für die Datenvorverarbeitung
In diesem Schritt laden, bereinigen und featurisieren wir das Dataset.
Daten laden
Wechsle die Rolle von Data-Manager zu Data Scientist und schreibe einen Prompt zum Laden der Daten.
Prompt: „Handle als professioneller Data Scientist und schreibe Python-Code, um fünf Tausend zufällige Stichproben aus dem Dataset für das oben genannte Projekt zu laden.“
Hinweis: Wir reduzieren die Datenmenge, um Modelle schneller zu trainieren und zu optimieren.
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()
Daten bereinigen
Damit unser Dataset sauber und analysierbar ist, geben wir Bard klare Anweisungen zu den notwendigen Bereinigungsfunktionen.
Prompt: „Schreibe jetzt eine Python-Funktion zur Bereinigung des Datasets. Die Funktion soll fehlende Werte entfernen, die Spalte \"Unnamed: 0\" droppen, Text bereinigen und Stoppwörter entfernen.“
Um Bugs oder Fehler im Code zu beheben, bitten wir Bard, den Stopword-Fehler zu lösen. Bard erkennt das Problem und liefert eine verbesserte Version des Codes.
Aktualisierter Prompt: „Behebe den Fehler mit den Stopwörtern.“
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()Wir haben jetzt ein ordentlich bereinigtes Dataset.
Feature Engineering
Damit Bard optimalen Code generiert, solltest du konkrete Anweisungen statt allgemeiner Fragen geben. Wenn wir Bard zum Beispiel bitten, eine bestimmte Funktion umzusetzen wie „Kombiniere die Länge beider Textspalten“, entsteht besser auf unser Projekt zugeschnittener Code.
Prompt: „Schreibe jetzt eine Python-Funktion für Feature Engineering. Wandle die title-Spalte in Kleinbuchstaben, kombiniere text und title, ermittle die Länge des kombinierten Texts, zähle eindeutige Wörter und mehr.“
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()Wir haben drei neue Features erstellt, die wir für die Datenanalyse nutzen.
Bard für Explorative Datenanalyse (EDA)
Im EDA-Teil lassen wir Bard gezielte Visualisierungen erstellen, die für die Datenerkundung wichtig sind.
Prompt: „Schreibe Python-Code für die Explorative Datenanalyse (EDA) zum obigen Projekt. Enthalte ein Histogramm zur kombinierten Länge von Fake vs. Real, die Labelverteilung und eine Wordcloud.“
Wir schreiben einen Folgeprompt, um Binkanten zu definieren.
Follow-up-Prompt: „Aktualisiere den EDA-Code mit `np.linspace`, um Binkanten von 0 bis 200 mit 40er-Binbreite zu erstellen.“
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()Es sieht so aus, als hätten Fake News eine längere Textlänge als echte Nachrichten.
# Label distribution
plt.pie(df['label'].value_counts(), labels=['Fake', 'Real'], autopct='%1.1f%%')
plt.show()Die Labelverteilung ist recht ausgeglichen, wir müssen also kein Klassenbalancing durchführen.
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 echten Nachrichten tauchen auffälligere Wörter wie „trump“ und „said“ auf als in Fake News.
Feature-Extraktion mit Bard
In diesem Teil schreiben wir einen Prompt, um die Spalte „text“ in Vektoren zu überführen und das Dataset in Trainings- und Testdaten zu splitten.
Prompt: „Wandle die Textspalte in Vektoren um und splitte das Dataset in Trainings- und Testdaten.“
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 für die Modellauswahl
Mit allen notwendigen Hintergrundinfos können wir jetzt direkte Fragen stellen.
Prompt: „Führe eine Modellauswahl durch.“
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
Alle getesteten Modelle schneiden solide ab. Der Support Vector Classifier (SVC) erreicht jedoch die höchste Genauigkeit.
Hyperparameter-Tuning mit Bard
Wir lassen Bard Code für das Hyperparameter-Tuning schreiben, der das optimale Modell und das Vectorizer-Objekt für das Deployment speichert.
Prompt: „Schreibe Python-Code für die Hyperparameteroptimierung von SVC. Speichere außerdem das beste Modell und den Vectorizer mit 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)Die Genauigkeit hat sich leicht verbessert.
Accuracy of the best model: 0.9298952457695407Das gespeicherte Modell und der Vectorizer werden für die Inferenz genutzt.
# Save the best model
joblib.dump(grid.best_estimator_, 'best_model.pkl')
# Save the TfidfVectorizer
joblib.dump(vectorizer, 'tfidf_vectorizer.pkl')Modellbewertung mit Bard
Genauigkeit allein reicht bei einem Klassifikationsmodell nicht. Wir prüfen auch F1-Score, Recall, Precision und die Konfusionsmatrix.
Prompt: „Schreibe Python-Code für die Modellbewertung. Enthalte Classification Report, Confusion Matrix und F1-Score.“
print(classification_report(y_test, y_pred))Laut Report ist unser Modell auf dem Testdatensatz sehr stabil.
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.9298892365447746Bard für eine Streamlit-Webapp
Nachdem die Ergebnisse überzeugen, entwickeln wir eine App, die den Eingabetext vektorisiert, durch das Modell schickt und das Ergebnis anzeigt.
Zuvor erstellen wir ein GitHub-Repository.
Klonen das Repository und speichere alle wesentlichen Komponenten der Anwendung. So sind sie sicher abgelegt und zugleich versionierst du App und Modell sauber.
git clone https://github.com/kingabzpro/Fake-News-DataCamp-Project.gitSchreibe einen generischen Prompt, um eine App zu entwickeln, die vorhersagt, ob eine Nachricht echt oder fake ist.
Prompt: „Schreibe eine separate Python-Datei für eine Web-App mit Streamlit, die vorhersagt, ob News (0 = fake oder 1 = real) sind. Nimm nur den Streamlit-App-Teil auf.“
Erstelle als Nächstes eine app.py-Datei und übertrage den Code aus Bard in diese Datei. Anschließend kannst du die Anwendung mit streamlit run app.py starten.
Hinweis: Stelle sicher, dass alle benötigten Python-Pakete für die Streamlit-App installiert sind.
Offenbar konnte Bard den Vectorizer nicht laden. Mit einem Folgeprompt beheben wir das.
Follow-up-Prompt: „Füge das Laden von Vectorizer und Modell in der App-Datei mit joblib hinzu.“
Die App läuft noch nicht rund, daher fügen wir einen Run-Button hinzu.
Follow-up-Prompt: „Füge außerdem einen Button hinzu, um die Inferenz zu starten.“
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.")Wir haben erfolgreich eine Streamlit-App gebaut, die Texteingaben annimmt und die Echtheit von Nachrichten beurteilt.
Bard für das Deployment auf Streamlit Cloud
Für das Cloud-Deployment bitten wir Bard um Hilfe. Es stellt sich heraus: Wir müssen nur unseren Code ins GitHub-Repository pushen und mit dem Streamlit-Server verbinden.
Prompt: „Hilf mir beim Deployment einer App auf der Streamlit Community Cloud.“
1. Erstelle eine requirements.txt und füge alle benötigten Python-Pakete wie „scikit-learn“ hinzu.
2. Füge die Dateien mit Git hinzu, committe und pushe auf den externen Server. Stelle sicher, dass Modell, Vectorizer, app.py und requirements.txt enthalten sind.
3. Gehe zu share.streamlit.io, klicke auf „New app“, wähle das GitHub-Repository und trage die nötigen Angaben zur App ein.
Das war’s. Unsere App ist deployed und öffentlich verfügbar auf Streamlit (fake-news-detector.streamlit.app).
Fazit
KI-Tools wie ChatGPT, Bard und Claude helfen uns, im Data-Science-Alltag zu brillieren. Richtig eingesetzt steigern sie Effizienz und Schlagkraft – und machen komplexe Datenaufgaben deutlich leichter handhabbar.
In diesem Beitrag haben wir gezeigt, wie leistungsfähig die neue Bard-Version für umfassende End-to-End-Data-Science-Projekte ist. Sieh dir auch unseren Leitfaden Using ChatGPT For Data Science Projects an oder belege den ausführlichen ChatGPT-Kurs: Introduction to ChatGPT, und lerne Best Practices für starke Prompts kennen.
