Kurs
ChatGPT verstehen
1 Std.
434.5K
Wir kennen alle die Popularität von ChatGPT und wie es die Produktivität steigert. Wenn du neu einsteigst, lohnt sich ein kostenloses Demo-Konto, um mit den Funktionen zu experimentieren. Außerdem empfehlen wir dir unseren Kurs Introduction to ChatGPT, um Best Practices für wirksame Prompts kennenzulernen und gängige Business-Use-Cases für dieses leistungsstarke KI-Tool zu erkunden.
In diesem Tutorial zeigen wir, wie du ChatGPT für ein End-to-End-Data-Science-Projekt nutzt. Mit passenden Prompts erstellen wir eine Projektstruktur, schreiben Python-Code, recherchieren und debuggen die Anwendung. Außerdem geben wir Tipps für gute ChatGPT-Prompts. Wenn dich der Einsatz von KI in verschiedenen Kontexten interessiert, lies unseren Guide zu KI-Projekten für alle Niveaus.
ChatGPT für ein End-to-End-Data-Science-Projekt nutzen
Für das Projekt verwenden wir die Loan Data aus DataLab und planen das Data-Science-Projekt darum herum.
ChatGPT übernimmt hier 80 Prozent der Arbeit. Wir müssen „Prompt Engineering“ beherrschen, um alles sauber zu steuern. Dafür gibt es unser praktisches ChatGPT Cheat Sheet für Data Science mit 60+ Prompts für SQL, R und Python.
Projektplanung
Das ist der wichtigste Teil: Wir prüfen Ressourcen und Ziele und leiten daraus die optimale Strategie ab.
Starte auf chat.openai.com einen neuen Chat. Erwähne dann das verfügbare Loan-Dataset und bitte ChatGPT, die Schritte für ein generisches End-to-End-Portfolio-Projekt zu skizzieren.
Prompt: „I have a loan dataset consisting of 9500 rows and 14 columns: ['credit.policy', 'purpose', 'int.rate', 'installment', 'log.annual.inc','dti', 'fico', 'days.with.cr.line', 'revol.bal', 'revol.util', 'inq.last.6mths', 'delinq.2yrs', 'pub.rec', 'not.fully.paid']. Can you list the steps I have to follow to develop an end-to-end project for my portfolio.”
Wir haben eine Liste bekommen, aber nichts zum Klassenungleichgewicht und zum Projektziel erwähnt: Wir wollen „loan not paid back” möglichst genau vorhersagen.
Updated Prompt: „Please include class imbalance issues and accurately predict whether a loan will not be paid back rather than if a loan is paid back.”
Außerdem interessieren wir uns nicht für Model Monitoring und wollen eine Gradio-App bauen und auf Hugging Face Spaces deployen.
Updated Prompt: „We will be creating a web app using Gradio and deploying it on Spaces and we won't be monitoring the model in the production.”
Gif vom Autor | Finale Liste der Projektschritte
Wir haben neun Schritte erhalten, wie oben gezeigt, inklusive detaillierter Erklärungen zum Vorgehen.
Das sind die Aufgaben, denen wir in diesem Tutorial folgen:
- Datenbereinigung und -vorverarbeitung. Fehlende Werte behandeln, kategoriale in numerische Variablen umwandeln, Daten skalieren/normalisieren und Ausreißer handhaben. Zusätzlich das Klassenungleichgewicht adressieren: entweder die Minderheitsklasse (nicht vollständig getilgte Kredite) überstichproben oder die Mehrheitsklasse (vollständig getilgte Kredite) unterstichproben.
- Explorative Datenanalyse (EDA). Verteilungen, Korrelationen und Muster erkunden, um Einblicke in die Daten zu gewinnen.
- Feature Engineering. Neue Merkmale erstellen oder bestehende transformieren, um die Vorhersagegüte zu erhöhen.
- Modellwahl. Mehrere Modelle ausprobieren, z. B. Entscheidungsbäume, Random Forests, logistische Regression oder Support Vector Machines (SVM).
- Modelltraining und -bewertung. Das gewählte Modell trainieren und mit Metriken wie Accuracy, Precision, Recall und F1-Score bewerten.
- Hyperparameter-Tuning. Die Hyperparameter des Modells feinjustieren, um die Performance zu verbessern.
- Web-App mit Gradio erstellen. Nach Auswahl des besten Modells eine Gradio-Web-App bauen.
- Deployment der Web-App auf Spaces. Die Gradio-App auf Spaces bereitstellen.
- Testing der Web-App. Testen, ob alles wie erwartet funktioniert.
Explorative Datenanalyse (EDA)
EDA umfasst Datenmanipulation, statistische Analyse und Visualisierung. Wir schreiben dazu einen Follow-up-Prompt, der Python-Code für die EDA unseres Datasets erzeugt.
Follow-Up Prompt: „Please write a Python code to load and perform Exploratory data analysis (EDA) on loan dataset”
Der Bot versteht den Kontext und liefert Python-Code mit Kommentaren und ausführlicher Erklärung.
Gif vom Autor | Python-Code für EDA
- Dataset als Pandas-DataFrame laden und anzeigen.
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
loan_df = pd.read_csv("loan_data.csv")
loan_df.head()
- Anzahl Zeilen/Spalten und statistische Kennzahlen für numerische Variablen ausgeben.
# Display the number of rows and columns in the dataset
print("Number of rows and columns:", loan_df.shape)
# Display summary statistics for numerical variables
print(loan_df.describe())Number of rows and columns: (9578, 14)
credit.policy int.rate ... pub.rec not.fully.paid
count 9578.000000 9578.000000 ... 9578.000000 9578.000000
mean 0.804970 0.122640 ... 0.062122 0.160054
std 0.396245 0.026847 ... 0.262126 0.366676
min 0.000000 0.060000 ... 0.000000 0.000000
25% 1.000000 0.103900 ... 0.000000 0.000000
50% 1.000000 0.122100 ... 0.000000 0.000000
75% 1.000000 0.140700 ... 0.000000 0.000000
max 1.000000 0.216400 ... 5.000000 1.000000- Fehlende Werte pro Spalte anzeigen. Wie man sieht: keine.
print(loan_df.isnull().sum())credit.policy 0
purpose 0
int.rate 0
installment 0
log.annual.inc 0
dti 0
fico 0
days.with.cr.line 0
revol.bal 0
revol.util 0
inq.last.6mths 0
delinq.2yrs 0
pub.rec 0
not.fully.paid 0- Verteilung der Zielvariable „not.fully.paid” visualisieren.
sns.countplot(x="not.fully.paid", data=loan_df)
plt.show()
- Korrelationen zwischen Variablen visualisieren.
corr = loan_df.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm")
plt.show()
- Verteilung der Kreditgründe verstehen.
sns.countplot(x="purpose", data=loan_df)
plt.xticks(rotation=90)
plt.show()
- Verteilung der Zinssätze nach Kreditgrund verstehen.
sns.boxplot(x="purpose", y="int.rate", data=loan_df)
plt.xticks(rotation=90)
plt.show()Feature Engineering
Statt umfangreicher Vorverarbeitung vereinfachen wir den Schritt durch gezieltes Feature Engineering.
Follow-up Prompt: „Write a Python code to perform feature engineering”
Wir haben eine brauchbare Lösung bekommen, aber inkl. irrelevanter Teile, daher haben wir mit einem Update-Prompt den Code angepasst.
Updated Prompt: „only add feature engineering part.”
# Perform feature engineering
loan_df["installment_to_income_ratio"] = (
loan_df["installment"] / loan_df["log.annual.inc"]
)
loan_df["credit_history"] = (loan_df["delinq.2yrs"] + loan_df["pub.rec"]) / loan_df[
"fico"
]ChatGPT hat zwei neue Features vorgeschlagen: „installment_to_income_ratio“ und „credit_history“.
Preprocessing und Klassenausgleich
ChatGPT kennt den Projektkontext, wir müssen nicht alles wiederholen. Wir bitten einfach um Python-Code zur Bereinigung und Vorverarbeitung.
Follow-up Prompt: „Now write a python code to clean and preprocess the dataset”
- Unnötige Spalten entfernen und kategoriale Variablen in numerische umwandeln.
from sklearn.preprocessing import LabelEncoder, StandardScaler
loan_df = loan_df.drop(['credit.policy', 'days.with.cr.line', 'purpose'], axis=1)
# Convert categorical variables to numerical using LabelEncoder
le = LabelEncoder()
loan_df['not.fully.paid'] = le.fit_transform(loan_df['not.fully.paid'])- Numerische Features mit StandardScaler skalieren.
scaler = StandardScaler()
numerical_cols = ['int.rate', 'installment', 'log.annual.inc', 'dti', 'fico', 'revol.bal', 'revol.util', 'inq.last.6mths', 'delinq.2yrs', 'pub.rec','credit_history','installment_to_income_ratio']
loan_df[numerical_cols] = scaler.fit_transform(loan_df[numerical_cols])- Klassendiskrepanz mit Oversampling aus imblearn ausgleichen.
from imblearn.over_sampling import SMOTE
sm = SMOTE(random_state=42)
X = loan_df.drop('not.fully.paid', axis=1)
y = loan_df['not.fully.paid']
X_resampled, y_resampled = sm.fit_resample(X, y)
loan_df = pd.concat([X_resampled, y_resampled], axis=1)
loan_df['not.fully.paid'].value_counts()Wie man sieht, ist die Klasse erfolgreich ausgeglichen.
0 8045
1 8045
Name: not.fully.paid, dtype: int64Modellwahl
Hier bitten wir ChatGPT, mehrere Modelle zu trainieren, um das beste auszuwählen.
Follow-up Prompt: „Write a follow-up python code for model selection. Try decision trees, random forests, logistic regression, or support vector machines (SVM). Note: only include the model selection part.”
Es erzeugt ein Skript, das in Train/Test splittet, die Modelle trainiert und die Accuracy ausgibt.
from sklearn.model_selection import train_test_split
# Split the dataset into training and testing sets
X = loan_df.drop('not.fully.paid', axis=1)
y = loan_df['not.fully.paid']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Fit and evaluate decision tree classifier
dt = DecisionTreeClassifier(random_state=42)
dt.fit(X_train, y_train)
dt_score = dt.score(X_test, y_test)
print("Decision Tree Classifier Accuracy: {:.2f}%".format(dt_score*100))
# Fit and evaluate random forest classifier
rf = RandomForestClassifier(random_state=42)
rf.fit(X_train, y_train)
rf_score = rf.score(X_test, y_test)
print("Random Forest Classifier Accuracy: {:.2f}%".format(rf_score*100))
# Fit and evaluate logistic regression classifier
lr = LogisticRegression(random_state=42)
lr.fit(X_train, y_train)
lr_score = lr.score(X_test, y_test)
print("Logistic Regression Classifier Accuracy: {:.2f}%".format(lr_score*100))
# Fit and evaluate support vector machine classifier
svm = SVC(random_state=42)
svm.fit(X_train, y_train)
svm_score = svm.score(X_test, y_test)
print("Support Vector Machine Classifier Accuracy: {:.2f}%".format(svm_score*100))Der Random-Forest-Algorithmus übertrifft die anderen Modelle deutlich.
Decision Tree Classifier Accuracy: 81.21%
Random Forest Classifier Accuracy: 89.14%
Logistic Regression Classifier Accuracy: 61.32%
Support Vector Machine Classifier Accuracy: 66.54%Hyperparameter-Tuning und Modellbewertung
Wir wählen das bessere Modell und bewerten es. Als Metriken setzen wir Accuracy, Precision, Recall und F1-Score ein und nutzen Cross-Validation für Stabilität.
Follow-up Prompt: „Select RandomForestClassifier and write a python code for model evaluation. Use accuracy, precision, recall, and F1 score as metric and cross-validation to ensure the model is not overfitting to the training data.”
Wir aktualisieren den Python-Code um Hyperparameter-Tuning und speichern das beste Modell.
Updated Prompt: „also include hyperparameter tuning in the above code and save the best-performing model”
Die finale Version nutzt GridSearchCV mit fünf Folds und f1 als Bewertungsmetrik, um die besten Hyperparameter zu finden.
Anschließend fügt ChatGPT automatisch Code hinzu, der das beste Modell für die Bewertung auf dem Testset verwendet und die optimalen Hyperparameter ausgibt.
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
# Define the parameter grid for hyperparameter tuning
param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [10, 20, 30, None],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4]
}
# Perform grid search with cross-validation to find the best hyperparameters
grid_search = GridSearchCV(rf, param_grid, cv=5, scoring='f1')
grid_search.fit(X_train, y_train)
# Get the best model and its hyperparameters
best_model = grid_search.best_estimator_
best_params = grid_search.best_params_
# Evaluate the best model on the testing set
y_pred = best_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
# Print the results
print("Random Forest Classifier Evaluation Results:")
print("Accuracy: {:.2f}%".format(accuracy * 100))
print("Precision: {:.2f}%".format(precision * 100))
print("Recall: {:.2f}%".format(recall * 100))
print("F1 Score: {:.2f}%".format(f1 * 100))
print("Best hyperparameters:", best_params)Wir erhalten ein stabiles Modell mit 89,35 Prozent Accuracy. Precision und Recall sind ähnlich.
Random Forest Classifier Evaluation Results:
Accuracy: 89.35%
Precision: 89.92%
Recall: 88.33%
F1 Score: 89.12%
Best hyperparameters: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 300}Zum Schluss speichern wir das Modell mit joblib.
import joblib
# Save the best model to disk
joblib.dump(best_model, 'loan_classifier.joblib')Den Quellcode mit Ausgaben findest du in diesem DataLab-Workbook. Du kannst dir leicht eine Kopie anlegen und den Code direkt im Browser ausführen, ganz ohne lokale Installation.
Eine Web-App mit Gradio erstellen
Jetzt kommt der Spaß: Wir erstellen per Prompts eine konfigurierbare Web-App, die numerische Eingaben entgegennimmt und Vorhersagen eines ML-Modells anzeigt.
ChatGPT kennt bereits den Kontext, daher bitten wir einfach um eine Gradio-App für den Loan-Classifier.
Follow-up Prompt: „Write the Python code to create a Gradio web app for loan data classifiers. We are not using columns ['credit.policy', 'days.with.cr.line', 'purpose'].”
Bitte ChatGPT, nur den Gradio-Teil für die Inferenz zu liefern, nicht Training + Inferenz.
Updated Prompt: „just include the gradio app part.”
Der Code zeigt die Klassenwahrscheinlichkeit, wir wollen aber die Klassenlabels ausgeben.
Updated Prompt: „modify the code to show classification instead of class probabilities.”
Beim Ausführen tauchten Warnungen und Fehler auf. Du kannst ChatGPT verbessern, indem du die Fehlermeldungen mitgibst.
Wir müssen die Grenzen von ChatGPT kennen. Es wurde auf älteren Daten trainiert. Wenn du erwartest, dass es auf die neueste API aktualisiert, läufst du ins Leere. Lies stattdessen die Gradio-Dokumentation und aktualisiere den Code manuell.
Failed Prompt: „update the Gradio code with component from gradio.components”
In der Gradio-App laden wir das gespeicherte Modell, nehmen Nutzereingaben entgegen und zeigen Vorhersagen an.
Lerne Gradio kennen in den Gradio Docs.
import gradio as gr
import joblib
# Load the trained model
model = joblib.load("loan_classifier.joblib")
def predict_loan_status(
int_rate,
installment,
log_annual_inc,
dti,
fico,
revol_bal,
revol_util,
inq_last_6mths,
delinq_2yrs,
pub_rec,
installment_to_income_ratio,
credit_history,
):
input_dict = {
"int.rate": int_rate,
"installment": installment,
"log.annual.inc": log_annual_inc,
"dti": dti,
"fico": fico,
"revol.bal": revol_bal,
"revol.util": revol_util,
"inq.last.6mths": inq_last_6mths,
"delinq.2yrs": delinq_2yrs,
"pub.rec": pub_rec,
"installment_to_income_ratio": installment_to_income_ratio,
"credit_history": credit_history,
}
# Convert the dictionary to a 2D array
input_array = [list(input_dict.values())]
prediction = model.predict(input_array)[0]
if prediction == 0:
return "Loan fully paid"
else:
return "Loan not fully paid"
inputs = [
gr.Slider(0.06, 0.23, step=0.01, label="Interest Rate"),
gr.Slider(100, 950, step=10, label="Installment"),
gr.Slider(7, 15, step=0.1, label="Log Annual Income"),
gr.Slider(0, 40, step=1, label="DTI Ratio"),
gr.Slider(600, 850, step=1, label="FICO Score"),
gr.Slider(0, 120000, step=1000, label="Revolving Balance"),
gr.Slider(0, 120, step=1, label="Revolving Utilization"),
gr.Slider(0, 10, step=1, label="Inquiries in Last 6 Months"),
gr.Slider(0, 20, step=1, label="Delinquencies in Last 2 Years"),
gr.Slider(0, 10, step=1, label="Public Records"),
gr.Slider(0, 5, step=0.1, label="Installment to Income Ratio"),
gr.Slider(0, 1, step=0.01, label="Credit History"),
]
outputs = [gr.Label(num_top_classes=2)]
title = "Loan Approval Classifier"
description = (
"Enter the details of the loan applicant to check if the loan is approved or not."
)
gr.Interface(
fn=predict_loan_status,
inputs=inputs,
outputs=outputs,
title=title,
description=description,
).launch()Du kannst den obigen Code als `app.py` speichern und die App im Browser starten, indem du im Terminal `python app.py` ausführst.
Gif vom Autor | Loan-Approval-Classifier-App
Auch wenn die App läuft, hat ChatGPT übersehen, dass wir numerische Features skaliert haben. Anstatt den Code über Prompts ändern zu lassen, speichere die Parameter des StandardScalers.
scalar = joblib.load('std_scaler.bin')Lade den Scaler dann in deiner App mit joblib.
input_array = [list(input_dict.values())]
scaled_array = scalar.transform(input_array)
prediction = model.predict(scaled_array)[0]Warum machen wir das manuell? Wenn du ChatGPT um eine kleine Anpassung bittest, ändert es möglicherweise den ganzen Code samt Variablennamen.
Ja, ChatGPT ist nicht perfekt und wird Entwickler nicht ersetzen.
Deployment der Web-App auf Spaces
Du kannst ChatGPT einfach nach einer Anleitung fragen, wie du eine Gradio-App auf Hugging Face Spaces deployst. Es liefert dir die nötigen Schritte.
Prompt: „how to deploy gradio app to huggingface spaces.”
- Gehe auf die Website von Hugging Face, klicke oben links auf dein Profilbild und wähle „New Space” aus.
Bild vom Autor
- Name und Lizenztyp eingeben, um das App-Repository zu erstellen.
- Auf Files and Versions > + Add file > Upload files klicken, um Dateien hochzuladen.
app.py, Modell- und Scaler-Dateien per Drag & Drop hinzufügen, dann auf „Commit change to main” klicken und eine Commit-Message vergeben. Ähnlich wie bei Git.
Bild vom Autor
Falls ein Runtime-Error auftritt, fehlt vermutlich die requirements.txt. Wähle Files and Versions > + Add file > Create a new file und füge Dateiname sowie Python-Bibliotheken mit Versionen wie unten gezeigt hinzu.
Bild vom Autor
Deine App ist einsatzbereit. Du kannst die Eingaben über Slider anpassen und vorhersagen, ob ein Kunde einen Kredit erhalten sollte.
Teste die Live-Demo auf einem Hugging Face Space von kingabzpro.
Bild vom Autor | Loan Classifier
Tipps für wirksame ChatGPT-Prompts
Prompt Engineering für reale Projekte ist knifflig. Wir müssen wissen, was geht und wo wir selbst eingreifen müssen, um ChatGPT zu korrigieren.
Hier ein paar Tipps, wie du ChatGPT effektiv nutzt, ohne dein Projekt zu gefährden.
- Schreibe klare, präzise Prompts. Erkläre am Anfang genau, was du brauchst.
- Baue Verlauf auf. ChatGPT ist ein Chatbot. Für gutes Kontextverständnis braucht es Verlauf.
- Dranbleiben. Es gibt keinen Standard für Prompts. Starte mit einem Basis-Prompt und verbessere ihn mit Follow-up- und Update-Prompts.
- Fehlermeldungen mitgeben. Wenn lokaler Code Fehler wirft, nenne die Meldung im Follow-up-Prompt. ChatGPT lernt sofort daraus und liefert oft die bessere Lösung.
- Manuell nachbessern. ChatGPT wurde auf älteren Daten trainiert. Für neue APIs oder Kniffe erwarte nicht zu viel. Nimm bei Bedarf manuelle Anpassungen vor, denn der generierte Code ist nicht perfekt.
- Für Standardaufgaben nutzen. Bei gängigen Aufgaben sind die Erfolgsaussichten höher.
- Zum Lernen einsetzen. Bitte ChatGPT, Neues zu erklären oder „How-to“-Anleitungen zu geben. Du bekommst einfache Schrittfolgen, die dich ans Ziel bringen – hilfreich auch bei Lernschwierigkeiten.
Wenn dich ChatGPT und die OpenAI API interessieren, melde dich für das Webinar an: Getting Started with the OpenAI API and ChatGPT. Du lernst Sprach- und Codegenerierung mit der OpenAI API und mehr.
Fazit
Einen Loan-Approval-Classifier zu entwickeln, ist nur ein Beispiel dafür, wie sich ChatGPT für Data-Science-Projekte einsetzen lässt. Wir können synthetische Daten generieren, SQL-Abfragen ausführen, Analytics-Reports erstellen, ML-Recherche betreiben und vieles mehr. Generative KI ist gekommen, um zu bleiben, und macht unseren Arbeitsalltag einfacher. Statt Wochen und Monaten kannst du Data-Science-Anwendungen in Stunden entwickeln, testen und deployen.
In diesem Tutorial haben wir ChatGPT für Projektplanung, Datenanalyse, Datenbereinigung und -vorverarbeitung, Modellwahl, Hyperparameter-Optimierung sowie das Erstellen und Deployen von Web-Anwendungen genutzt.
Es gibt einen Haken: Du brauchst Erfahrung mit statistischer Analyse und Python, um die Projektaufgaben wirklich zu verstehen. Ohne dieses Fundament tappst du im Dunkeln. Starte deine Data-Science-Reise mit dem Lernpfad Data Scientist with Python und baue dir die Kompetenzen auf, die du für deine Karriere als Data Scientist brauchst.