Cursus
ChatGPT begrijpen
1 uur
435.9K
We kennen allemaal de populariteit van ChatGPT en hoe mensen het gebruiken om hun productiviteit te verhogen. Maar als je nieuw bent, is het de moeite waard om je aan te melden voor een gratis demo van ChatGPT en te experimenteren met alles wat het kan. Volg ook onze cursus Introduction to ChatGPT om best practices te leren voor het maken van effectieve prompts en om veelvoorkomende zakelijke use-cases te verkennen voor het inzetten van deze krachtige AI-tool.
In deze tutorial leren we hoe we ChatGPT kunnen gebruiken om aan een end-to-end data science-project te werken. We gebruiken verschillende prompts om een projectopzet te maken, Python-code te schrijven, onderzoek te doen en de applicatie te debuggen. Bovendien leren we tips voor het schrijven van effectieve ChatGPT-prompts. Ben je benieuwd naar het gebruik van AI voor verschillende doelen, bekijk dan onze gids met AI-projecten voor alle niveaus.
ChatGPT gebruiken voor een end-to-end data science-project
In het project gebruiken we de Loan Data uit DataLab en plannen we daar ons data science-project omheen.
ChatGPT doet hier 80 procent van het werk; wij hoeven alleen prompt engineering onder de knie te krijgen om alles goed te krijgen, en daarvoor hebben we onze geweldige ChatGPT-cheat sheet voor data science. Die bevat meer dan 60 ChatGPT-prompts voor data science-taken op basis van SQL, R en Python.
Projectplanning
Dit is het belangrijkste deel van het project, waarin we naar de beschikbare middelen en doelen kijken om met een optimale strategie te komen.
Je kunt naar chat.openai.com gaan en een nieuwe chat starten. Daarna geven we de beschikbare loan-dataset door en vragen we ChatGPT om stappen te bedenken voor het bouwen van een end-to-end generiek portfolio-project.
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.”
We kregen de lijst, maar we vergaten het class imbalance-probleem en het projectdoel te vermelden, namelijk om “lening niet terugbetaald” nauwkeurig te voorspellen.
Bijgewerkte 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.”
Verder zijn we niet geïnteresseerd in modelmonitoring, en we willen een Gradio-app bouwen en die deployen op Hugging Face Spaces.
Bijgewerkte 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 door auteur | Definitieve lijst met stappen in een project
We kregen een lijst van 9 stappen, zoals hierboven te zien is, en een gedetailleerde uitleg over hoe we elke stap moeten aanpakken.
Hier is de takenlijst die we in deze tutorial gaan volgen:
- Opschonen en preprocessing van data. Omgaan met missende waarden, categorische variabelen omzetten naar numeriek, de data schalen/normaliseren en eventuele uitschieters of anomalieën in de data behandelen. Daarnaast wil je de class imbalance aanpakken door óf de minderheidsklasse (leningen die niet volledig zijn terugbetaald) te oversamplen óf de meerderheidsklasse (leningen die wel volledig zijn terugbetaald) te undersamplen.
- Exploratory data analysis (EDA). De dataset verkennen om inzichten te krijgen, zoals verdelingen van variabelen, correlaties tussen variabelen en het identificeren van patronen in de data.
- Feature engineering. Nieuwe features creëren of bestaande transformeren om het voorspellend vermogen van het model te verbeteren.
- Modelselectie. Probeer meerdere modellen, zoals decision trees, random forests, logistic regression of support vector machines (SVM).
- Modeltraining en -evaluatie. Het geselecteerde model trainen op de data en de prestaties evalueren met verschillende metrics zoals accuracy, precision, recall en F1-score.
- Hyperparametertuning. De hyperparameters van het geselecteerde model fijn afstellen om de prestaties te verbeteren.
- De webapp bouwen met Gradio. Zodra je het beste model hebt gekozen, kun je met Gradio een webapp maken.
- De webapp deployen op Spaces. Nadat je de webapp met Gradio hebt gemaakt, kun je deze op Spaces deployen.
- De webapp testen. Test of alles werkt zoals verwacht.
Exploratory Data Analysis (EDA)
Exploratory data analysis draait om datamanipulatie, statistische analyse en datavisualisatie. We kunnen dit afronden met een follow-upprompt om Python-code te laten schrijven voor EDA op onze dataset.
Follow-upprompt: “Please write a Python code to load and perform Exploratory data analysis (EDA) on loan dataset”
De bot begrijpt de context en komt met Python-code met commentaar en een gedetailleerde uitleg van hoe het werkt.
Gif door auteur | Python-code voor EDA
- De dataset laden en weergeven als Pandas DataFrame.
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
loan_df = pd.read_csv("loan_data.csv")
loan_df.head()
- Het aantal rijen en kolommen en de statistische samenvatting voor numerieke variabelen weergeven.
# 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- Missende waarden per kolom weergeven. Zoals we zien, zijn die er niet.
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- De verdeling van de targetvariabele “not.fully.paid” visualiseren.
sns.countplot(x="not.fully.paid", data=loan_df)
plt.show()
- De correlatie tussen variabelen visualiseren.
corr = loan_df.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm")
plt.show()
- De verdeling van het leendoel begrijpen.
sns.countplot(x="purpose", data=loan_df)
plt.xticks(rotation=90)
plt.show()
- De verdeling van rentepercentages per leendoel begrijpen.
sns.boxplot(x="purpose", y="int.rate", data=loan_df)
plt.xticks(rotation=90)
plt.show()Feature engineering
In plaats van de data te preprocessen en op te schonen, voeren we feature engineering uit om de preprocesstaak te vereenvoudigen.
Follow-upprompt: “Write a Python code to perform feature engineering”
We kregen de juiste oplossing, maar die bevatte irrelevante code; daarom schreven we een updateprompt om de code aan te passen.
Bijgewerkte 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 heeft twee nieuwe features voorgesteld: “installment_to_income_ratio” en “credit_history”.
Preprocessing en balanceren van de data
Ook hier kent ChatGPT de context van het project. We hoeven niet alles opnieuw uit te leggen. We vragen dus simpelweg om Python-code te schrijven om de data op te schonen en te preprocessen.
Follow-upprompt: “Now write a python code to clean and preprocess the dataset”
- Onnodige kolommen droppen en categorische variabelen omzetten naar numeriek.
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'])- De numerieke features schalen met StandardScaler.
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])- Class imbalance aanpakken met imblearn’s oversampling-methode.
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()Zoals we zien, hebben we de klassen succesvol in balans gebracht.
0 8045
1 8045
Name: not.fully.paid, dtype: int64Modelselectie
In dit onderdeel vroegen we ChatGPT om de data op verschillende modellen te trainen voor een modelselectietaak.
Follow-upprompt: “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.”
Er is een Python-script gegenereerd om de dataset te splitsen in train en test en de genoemde modellen te trainen om de accuracymetrics te tonen.
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))Het Random Forest-algoritme presteerde aanzienlijk beter dan de andere modellen.
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%Hyperparametertuning en modelevaluatie
We kiezen het best presterende model en voeren de modelevaluatie uit. We hebben het gebruik van accuracy, precision, recall en F1-score als metrics gespecificeerd en cross-validatie om de modelstabiliteit te waarborgen.
Follow-upprompt: “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.”
We werken de Python bij om hyperparametertuning toe te voegen en het best presterende model op te slaan.
Bijgewerkte prompt: “also include hyperparameter tuning in the above code and save the best-performing model”
De definitieve versie van de code gebruikt GridSearchCV voor hyperparametertuning met vijf cross-validatiesplits en gebruikt de f1-metric voor evaluatie om de beste hyperparameters te vinden.
Daarna voegde ChatGPT automatisch de code toe om het beste model te selecteren voor modelevaluatie op de testset en de best presterende hyperparameters weer te geven.
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)We hebben een stabiel model met een accuracy van 89,35. Zowel precision als recall zijn vergelijkbaar.
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}Tot slot slaan we het model op met joblib.
import joblib
# Save the best model to disk
joblib.dump(best_model, 'loan_classifier.joblib')Je vindt de broncode met de outputs in deze DataLab-workbook; je kunt eenvoudig je eigen kopie maken om de code in de browser te bewerken en uit te voeren, allemaal zonder iets te hoeven installeren op je computer.
Een webapp maken met Gradio
Nu komt het leukste deel. We gebruiken alleen prompts om een volledig aanpasbare webapp te maken die numerieke input neemt en de resultaten toont met een machinelearningmodel.
ChatGPT kent de context al, dus we hoeven alleen te vragen om een Gradio-webapp te schrijven voor de loan data-classifier.
Follow-upprompt: “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'].”
Vraag ChatGPT om alleen het Gradio-appgedeelte op te nemen in plaats van training en vervolgens het inferentiescript.
Bijgewerkte prompt: “just include the gradio app part.”
De code die we kregen toont de voorspellingswaarschijnlijkheid per klasse, maar we willen classificatielabels tonen.
Bijgewerkte prompt: “modify the code to show classification instead of class probabilities.”
Na het uitvoeren van de code zagen we meerdere waarschuwingen en fouten. Je kunt dit verbeteren door de fouten aan ChatGPT te melden.
We moeten de beperkingen van ChatGPT begrijpen. Het is getraind op een oude dataset, en als je verwacht dat het de code bijwerkt met de nieuwste API, loop je vast. Lees in plaats daarvan de documentatie van Gradio en werk de code handmatig bij.
Mislukte prompt: “update the Gradio code with component from gradio.components”
In de Gradio-app laden we het opgeslagen model en halen we input van gebruikers op om modelvoorspellingen te tonen.
Leer hoe Gradio werkt door de Gradio Docs te lezen.
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()Je kunt de bovenstaande code opslaan in het bestand `app.py` en de app in de browser starten door in de terminal het script `python app.py` uit te voeren.
Gif door auteur | Loan approval-classifier app
Hoewel onze app prima werkt, heeft ChatGPT volledig gemist dat we de numerieke features hebben geschaald. In plaats van te vragen om de code bij te werken, kun je teruggaan en de parameters van de standard scaler opslaan.
scalar = joblib.load('std_scaler.bin')Laad daarna de scaler in je app met joblib.
input_array = [list(input_dict.values())]
scaled_array = scalar.transform(input_array)
prediction = model.predict(scaled_array)[0]Waarom doen we dit handmatig? Als je ChatGPT vraagt om één regel aan te passen, kan het de hele code en zelfs variabelenamen wijzigen.
Ja, ChatGPT is niet perfect en zal een ontwikkelaar nooit vervangen.
De webapp deployen op Spaces
Je kunt ChatGPT eenvoudig vragen om je de simpele manier te leren om een Gradio-app op Hugging Face Spaces te deployen, en het zal de nodige stappen opsommen.
Prompt: “how to deploy gradio app to huggingface spaces.”
- Ga naar de website van Hugging Face en klik linksboven op je profielfoto om de optie “New Space” te selecteren.
Afbeelding door auteur
- Voeg de naam en het type licentie toe om de app-repository te maken.
- Klik op Files and Versions > + Add file > Upload files om bestanden aan de repository toe te voegen.
- Sleep de bestanden app.py, model en scaler naar de pagina en klik op de knop “Commit change to main'' en sla de commit op met een commitbericht. Vergelijkbaar met Git.
Afbeelding door auteur
Krijg je een runtime-fout, dan ben je waarschijnlijk vergeten ook een requirements.txt toe te voegen. Kies Files and Versions > + Add file > Create a new file en voeg de bestandsnaam en Python-bibliotheken met versies toe zoals hieronder getoond.
Afbeelding door auteur
Je app is klaar. Je kunt de input aanpassen met sliders en voorspellen of de klant een lening zou moeten krijgen of niet.
Je kunt de live demo proberen op een Hugging Face Space van kingabzpro.
Afbeelding door auteur | Loan Classifier
Tips voor het schrijven van effectieve ChatGPT-prompts
Prompt engineering is lastig wanneer je het in echte projecten gebruikt. We moeten de regels begrijpen over wat we kunnen doen en waar we moeten ingrijpen om ChatGPT te corrigeren.
Hier zijn enkele tips om je ervaring met ChatGPT te verbeteren zonder het project in gevaar te brengen.
- Schrijf altijd duidelijke en beknopte prompts. Leg aan het begin in detail uit wat je nodig hebt.
- Bouw projectgeschiedenis op. ChatGPT is een chatbot, dus om de context effectief te begrijpen, moet je geschiedenis opbouwen.
- Blijf proberen. Er is geen standaardmanier om prompts te schrijven. Begin met een basismededeling en blijf verbeteren door follow-up- en updateprompts te schrijven.
- Noem codefouten. Als je de code lokaal draait en er treedt een fout op, vermeld die fout in de follow-upprompt. ChatGPT leert er direct van en komt met een betere oplossing.
- Breng wijzigingen handmatig aan. ChatGPT is getraind op oude data en als je verwacht dat het met nieuwe ideeën of API-commando’s komt, raak je teleurgesteld. Breng waar mogelijk handmatige wijzigingen aan in je code, want de gegenereerde code is niet perfect.
- Gebruik het voor gangbare taken. De kans op succes met ChatGPT is groter als je om gangbare taken vraagt.
- Gebruik het om iets nieuws te leren. Vraag ChatGPT altijd om nieuwe dingen uit te leggen of om “how-to”-tutorials. Het geeft je een lijst met eenvoudige stappen om het werk gedaan te krijgen. Het is behoorlijk handig als je een leerstoornis hebt.
Als je geïnteresseerd bent in ChatGPT en de OpenAI API, schrijf je dan in voor het webinar: Getting Started with the OpenAI API and ChatGPT. Je leert taalen codegeneratietaken uitvoeren met de OpenAI API en veel meer.
Conclusie
Een loan approval-classifier ontwikkelen is slechts één van de vele voorbeelden van het gebruik van ChatGPT voor data science-projecten. We kunnen het gebruiken om synthetische data te genereren, SQL-queries uit te voeren, data-analyserapporten te maken, machinelearningonderzoek te doen en nog veel meer. Generatieve AI is blijvend en zal ons leven makkelijker maken. In plaats van weken of maanden aan een project te besteden, kun je data science-applicaties in uren ontwikkelen, testen en deployen.
In deze tutorial hebben we geleerd om ChatGPT te gebruiken voor projectplanning, data-analyse, data opschonen en preprocessen, modelselectie, hyperparameteroptimalisatie en het bouwen en deployen van webapplicaties.
Er zit wel een addertje onder het gras bij het gebruik van ChatGPT. Je hebt ervaring nodig met statistische analyse en Python-codering om de verschillende taken in het project te begrijpen; zonder die ervaring loop je blind. Start je data science-reis met het volgen van de carrièretrack Data Scientist with Python en ontwikkel de carrièreskills die je nodig hebt om als data scientist te slagen.
Onderwerpen
