Guide d’utilisation de ChatGPT pour des projets de data science

Nous connaissons tous la popularité de ChatGPT et la façon dont il aide à doper la productivité. Si vous débutez, cela vaut la peine de créer un compte et d’essayer la démo gratuite pour explorer tout ce qu’il peut faire. Suivez aussi notre cours Introduction to ChatGPT pour découvrir les bonnes pratiques de rédaction de prompts efficaces et des cas d’usage métier courants pour tirer parti de cet outil d’IA puissant.

Dans ce tutoriel, nous allons voir comment utiliser ChatGPT pour mener un projet de data science de bout en bout. Nous utiliserons différents prompts pour établir le plan du projet, écrire du code Python, faire de la recherche et déboguer l’application. Nous partagerons également des conseils pour rédiger des prompts ChatGPT efficaces. Si l’idée d’utiliser l’IA à diverses fins vous intrigue, consultez notre guide sur des projets d’intelligence artificielle pour tous les niveaux.

Utiliser ChatGPT pour un projet de data science de bout en bout

Dans ce projet, nous utiliserons les données de prêts issues de DataLab et nous construirons notre projet de data science autour de ce jeu de données. 

ChatGPT fait ici 80 % du travail. À nous de maîtriser le prompt engineering pour obtenir des résultats pertinents. Pour cela, appuyez-vous sur notre excellent aide‑mémoire ChatGPT pour la data science, qui propose plus de 60 prompts pour des tâches en SQL, R et Python. 

Planification du projet

Il s’agit de l’étape la plus importante : à partir des ressources disponibles et des objectifs, nous définissons une stratégie optimale. 

Accédez à chat.openai.com et ouvrez une nouvelle conversation. Ensuite, mentionnez le dataset de prêts dont vous disposez et demandez à ChatGPT de proposer les étapes pour construire un projet générique de bout en bout pour votre portfolio. 

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. »

Nous avons obtenu une liste, mais nous avons oublié de mentionner le déséquilibre de classes et l’objectif du projet, qui est de prédire avec précision « loan not paid back » (prêt non remboursé). 

Prompt mis à jour : « Please include class imbalance issues and accurately predict whether a loan will not be paid back rather than if a loan is paid back. »

Par ailleurs, nous ne souhaitons pas faire de monitoring du modèle et nous voulons créer une application Gradio et la déployer sur Hugging Face Spaces. 

Prompt mis à jour : « 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 par l’auteur | Liste finale des étapes d’un projet

Nous avons obtenu une liste de 9 étapes (voir ci‑dessus) avec une explication détaillée de l’approche à adopter pour chacune. 

Voici les tâches que nous suivrons dans ce tutoriel :

• Nettoyage et prétraitement des données. Gérer les valeurs manquantes, convertir les variables catégorielles en variables numériques, mettre à l’échelle/normaliser les données et traiter les valeurs aberrantes. En outre, vous devrez traiter le déséquilibre de classes en sur‑échantillonnant la classe minoritaire (prêts non entièrement remboursés) ou en sous‑échantillonnant la classe majoritaire (prêts entièrement remboursés).
• Analyse exploratoire des données (EDA). Explorer le jeu de données pour comprendre les distributions, les corrélations et identifier des motifs éventuels.
• Feature engineering. Créer de nouvelles variables ou transformer les variables existantes pour améliorer le pouvoir prédictif du modèle. 
• Sélection de modèles. Tester plusieurs modèles : arbres de décision, forêts aléatoires, régression logistique, machines à vecteurs de support (SVM). 
• Entraînement et évaluation. Entraîner le modèle retenu et évaluer ses performances avec des métriques telles que l’exactitude, la précision, le rappel et le F1‑score. 
• Optimisation d’hyperparamètres. Ajuster finement les hyperparamètres du modèle pour améliorer ses performances. 
• Création de l’application web avec Gradio. Une fois le meilleur modèle sélectionné, créer l’application web avec Gradio. 
• Déploiement sur Spaces. Déployer ensuite l’application sur Spaces. 
• Tests. Tester l’application pour vérifier qu’elle fonctionne comme prévu.

Analyse exploratoire des données (EDA) 

L’EDA combine manipulation de données, analyse statistique et visualisation. Nous pouvons la réaliser en rédigeant un prompt de suivi pour générer le code Python correspondant sur notre dataset. 

Prompt de suivi : « Please write a Python code to load and perform Exploratory data analysis (EDA) on loan dataset »

Le bot comprend le contexte et produit du code Python avec des commentaires et des explications détaillées. 

Gif par l’auteur | Code Python pour l’EDA

1. Charger et afficher le dataset sous forme de dataframe Pandas. 

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

loan_df = pd.read_csv("loan_data.csv")

loan_df.head()

2. Afficher le nombre de lignes et de colonnes, ainsi qu’un résumé statistique des variables numériques. 

# 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

3. Afficher les valeurs manquantes par colonne. Comme on le voit, il n’y en a pas. 

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

4. Visualiser la distribution de la variable cible « not.fully.paid ».

sns.countplot(x="not.fully.paid", data=loan_df)
plt.show()

5. Visualiser les corrélations entre variables.

corr = loan_df.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm")
plt.show()

6. Comprendre la distribution des finalités de prêt.

sns.countplot(x="purpose", data=loan_df)
plt.xticks(rotation=90)
plt.show()

7. Analyser la distribution des taux d’intérêt selon la finalité du prêt.

sns.boxplot(x="purpose", y="int.rate", data=loan_df)
plt.xticks(rotation=90)
plt.show()

Feature engineering

Plutôt que de prétraiter et nettoyer en profondeur, nous allons créer des variables dérivées pour simplifier le prétraitement. 

Prompt de suivi : « Write a Python code to perform feature engineering »

Nous avons obtenu une solution correcte, mais avec du code hors sujet. Nous avons donc envoyé un prompt de mise à jour pour ne garder que l’essentiel. 

Prompt mis à jour : « 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 a suggéré deux nouvelles variables : « installment_to_income_ratio » et « credit_history ».

Prétraitement et rééquilibrage des données

Encore une fois, ChatGPT connaît le contexte. Inutile de tout réexpliquer. Demandons‑lui simplement d’écrire le code Python pour nettoyer et prétraiter les données. 

Prompt de suivi : « Now write a python code to clean and preprocess the dataset »

1. Supprimer les colonnes non nécessaires et convertir les variables catégorielles en numériques.

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'])

2. Mettre à l’échelle les variables numériques avec 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])

3. Gérer le déséquilibre de classes via la méthode de sur‑échantillonnage d’imblearn. 

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

Comme on le voit, les classes ont été rééquilibrées avec succès. 

0    8045
1    8045
Name: not.fully.paid, dtype: int64

Sélection de modèles

Ici, nous demandons à ChatGPT d’entraîner différents modèles pour comparer leurs performances.  

Prompt de suivi : « 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. »

Il a généré un script Python pour séparer les données en apprentissage/test, entraîner les modèles indiqués et afficher l’exactitude obtenue.

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

L’algorithme Random Forest surpasse nettement les autres modèles.  

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%

Optimisation d’hyperparamètres et évaluation du modèle 

Nous allons retenir le modèle le plus performant et procéder à l’évaluation. Nous avons choisi les métriques exactitude, précision, rappel et F1, ainsi que la validation croisée pour vérifier la robustesse du modèle.

Prompt de suivi : « 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. »

Nous mettrons ensuite à jour le code pour inclure l’optimisation d’hyperparamètres et l’enregistrement du meilleur modèle. 

Prompt mis à jour : « also include hyperparameter tuning in the above code and save the best-performing model »

La version finale utilise GridSearchCV avec cinq plis de validation croisée et l’indicateur f1 pour trouver les meilleurs hyperparamètres. 

Ensuite, ChatGPT a ajouté le code pour évaluer le meilleur modèle sur l’ensemble de test et afficher les hyperparamètres optimaux. 

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)

Nous obtenons un modèle stable avec 89,35 % d’exactitude. La précision et le rappel sont proches. 

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}

Enfin, nous enregistrons le modèle avec joblib. 

import joblib
# Save the best model to disk
joblib.dump(best_model, 'loan_classifier.joblib')

Vous pouvez consulter le code source et les sorties dans ce workbook DataLab : créez facilement votre propre copie pour modifier et exécuter le code dans le navigateur, sans rien installer sur votre ordinateur. 

Créer une application web avec Gradio

Voici la partie la plus ludique. Nous allons nous contenter de prompts pour créer une application web entièrement personnalisable qui prend des entrées numériques et affiche les résultats à l’aide d’un modèle de machine learning. 

ChatGPT connaît déjà le contexte : demandez‑lui simplement d’écrire l’app Gradio pour notre classifieur de prêts. 

Prompt de suivi : « 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']. »

Demandez à ChatGPT d’inclure uniquement la partie application Gradio, sans l’entraînement ni le script d’inférence. 

Prompt mis à jour : « just include the gradio app part. »

Le code retourné affiche la probabilité de classe, alors que nous souhaitons voir les étiquettes de classification. 

Prompt mis à jour : « modify the code to show classification instead of class probabilities. »

Après exécution, nous avons observé plusieurs avertissements et erreurs. Vous pouvez améliorer le code en les indiquant à ChatGPT. 

Gardez à l’esprit les limites de ChatGPT. Il a été entraîné sur des données historiques : si vous lui demandez d’adapter le code aux toutes dernières API, vous risquez d’être bloqué. Lisez plutôt la documentation Gradio et mettez le code à jour manuellement. 

Prompt infructueux : « update the Gradio code with component from gradio.components »

Dans l’application Gradio, nous chargeons le modèle enregistré, recueillons les entrées utilisateur et affichons la prédiction. 

Pour comprendre le fonctionnement de Gradio, consultez les 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()

Enregistrez le code ci‑dessus dans un fichier `app.py`, puis lancez l’application dans le navigateur avec la commande `python app.py` dans le terminal. 

Gif par l’auteur | Application d’approbation de prêt

Même si l’application fonctionne, ChatGPT a totalement omis le fait que nous avions mis à l’échelle les variables numériques. Plutôt que de lui demander de modifier le code, revenez en arrière et enregistrez les paramètres du standard scaler. 

scalar = joblib.load('std_scaler.bin')

Chargez ensuite le scaler dans votre application à l’aide de joblib.

input_array = [list(input_dict.values())]
scaled_array = scalar.transform(input_array)
prediction = model.predict(scaled_array)[0]

Pourquoi le faire manuellement ? Parce qu’en lui demandant de modifier une seule ligne, ChatGPT peut réécrire tout le script et même renommer des variables. 

Oui, ChatGPT n’est pas parfait et ne remplacera jamais un développeur. 

Déployer l’application web sur Spaces

Demandez simplement à ChatGPT de vous expliquer la façon la plus simple de déployer une application Gradio sur Hugging Face Spaces : il énumérera les étapes nécessaires. 

Prompt : « how to deploy gradio app to huggingface spaces. »

1. Allez sur le site Hugging Face, cliquez sur votre photo de profil en haut à gauche et choisissez « New Space ».  

Image par l’auteur

2. Renseignez le nom et la licence pour créer le dépôt de l’application. 
3. Cliquez sur Files and Versions > + Add file > Upload files pour ajouter des fichiers au dépôt. 
4. Glissez‑déposez les fichiers app.py, le modèle et le scaler, puis cliquez sur « Commit change to main » et ajoutez un message de commit, comme sur Git.

Image par l’auteur

Si vous obtenez une erreur d’exécution, vous avez probablement oublié d’ajouter le fichier requirements.txt. Allez dans Files and Versions > + Add file > Create a new file, puis indiquez le nom du fichier et les bibliothèques Python avec leurs versions comme ci‑dessous. 

Image par l’auteur

Votre application est prête. Vous pouvez ajuster les entrées avec les curseurs et prédire si un client devrait obtenir un prêt ou non. 

Testez la démo en direct sur un Space Hugging Face par kingabzpro.

Image par l’auteur | Loan Classifier

Conseils pour rédiger des prompts ChatGPT efficaces

Le prompt engineering peut être délicat dans des projets réels. Il faut comprendre ce que l’on peut déléguer et à quel moment intervenir pour corriger ChatGPT. 

Voici quelques conseils pour améliorer votre expérience avec ChatGPT sans compromettre le projet.

1. Rédigez des prompts clairs et concis. Expliquez d’emblée précisément ce dont vous avez besoin.
2. Installez un historique de projet. ChatGPT est un chatbot : pour qu’il saisisse efficacement le contexte, construisez un fil de discussion cohérent. 
3. Itérez. Il n’existe pas de formule unique. Partez d’un prompt de base et améliorez‑le avec des prompts de suivi.  
4. Signalez les erreurs de code. Si le code lève une erreur en local, mentionnez‑la dans un prompt de suivi. ChatGPT apprendra immédiatement de l’erreur et proposera une meilleure solution. 
5. Faites des ajustements manuels. ChatGPT a été entraîné sur des données anciennes : si vous attendez de lui de nouvelles idées ou des commandes d’API récentes, vous serez déçu. Modifiez manuellement votre code quand c’est possible, car le code généré n’est pas parfait. 
6. Utilisez‑le pour des tâches courantes. Les chances de réussite augmentent quand vous lui confiez des tâches fréquentes.
7. Servez‑vous‑en pour apprendre. Demandez des explications ou des tutoriels « comment faire ». Vous obtiendrez des étapes simples et actionnables, utile notamment en cas de trouble de l’apprentissage. 

Si ChatGPT et l’API OpenAI vous intéressent, inscrivez‑vous au webinar : Getting Started with the OpenAI API and ChatGPT. Vous apprendrez à réaliser des tâches de génération de langage et de code avec l’API OpenAI, et bien plus encore.

Conclusion

Créer un classifieur d’approbation de prêt n’est qu’un exemple parmi d’autres d’utilisation de ChatGPT pour des projets de data science. On peut aussi générer des données synthétiques, exécuter des requêtes SQL, produire des rapports d’analyse, mener des recherches en machine learning, et bien plus. L’IA générative est là pour durer et nous simplifiera la vie. Au lieu d’y passer des semaines ou des mois, vous pouvez développer, tester et déployer des applications de data science en quelques heures. 

Dans ce tutoriel, nous avons utilisé ChatGPT pour la planification, l’analyse de données, le nettoyage et le prétraitement, la sélection de modèles, l’optimisation d’hyperparamètres, ainsi que la création et le déploiement d’applications web. 

Il y a toutefois un prérequis : vous devez avoir des bases en analyse statistique et en Python pour bien comprendre les différentes étapes. Sans cela, vous avancerez à l’aveugle. Lancez‑vous dans la data science avec le parcours carrière Data Scientist with Python et développez les compétences indispensables pour réussir.