Tutoriel OpenAI o1-preview : créer un projet de machine learning

Premiers pas avec o1-preview et o1-mini

Il existe de nombreux accès faciles aux modèles o1, mais les voies officielles passent soit par l’API OpenAI, soit par un abonnement ChatGPT Plus ou Team. 

Dans cette section, nous allons voir comment les utiliser pour résoudre des problèmes complexes.

Accéder au modèle o1

Si vous connaissez l’API OpenAI pour les complétions de conversation, il suffit de définir le nom du modèle sur "o1-preview" et de fournir un prompt détaillé. C’est aussi simple que ça.

from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user", 
            "content": "Create an SQL database from scratch, including guides on usage and code everything in Python."
        }
    ]
)

print(response.choices[0].message.content)

Sur ChatGPT, cliquez sur la liste déroulante de sélection des modèles et choisissez le modèle « o1-preview », comme ci-dessous.

Utiliser le modèle o1-preview dans ChatGPT

Les prompts d’o1 diffèrent : il faut fournir plusieurs consignes ou des questions détaillées pour en tirer toute la puissance. Il gère des instructions longues et complexes pour produire une réponse optimale.

Calculer les impôts d’une activité indépendante en Europe peut être complexe. Nous allons utiliser o1 pour estimer notre charge fiscale en Espagne.

Prompt : « Je suis travailleur indépendant en Espagne pour une entreprise basée aux États-Unis. Sur l’année, j’ai gagné 120 000 USD et je dois calculer le montant des impôts dus. Merci de prendre en compte que j’ai emmenagé en Espagne il y a 8 mois. »

La réponse a pris près de 30 secondes, mais elle est très détaillée : équations, informations fiscales et tous les éléments utiles pour estimer les impôts dus en Espagne.

La réponse est structurée en plusieurs parties :

1. Déterminer votre résidence fiscale
2. Convertir vos revenus en euros
3. Calculer votre revenu imposable
4. Calculer les cotisations sociales
5. Total estimé des impôts dus
6. Points importants
7. Prochaines étapes

Le récapitulatif donne un montant approximatif à payer : très utile pour s’y retrouver. 

Vous pouvez dérouler la réponse pour visualiser la chaîne de pensée et les choix effectués. 

On constate que le modèle comprend le contexte, les implications fiscales et les tranches d’imposition avant de répondre.

Utiliser le modèle o1-mini dans ChatGPT

o1-mini est moins précis mais plus rapide qu’o1-preview. Ici, nous l’utiliserons pour créer un site statique pour un CV en data science.

Prompt : « Créez un site statique pour mon CV de data scientist avec un framework Python. »

Non seulement il génère un site de CV correct, mais il indique aussi comment le publier gratuitement sur GitHub Pages.

La réponse est structurée en :

1. Introduction à Pelican
2. Prérequis
3. Configuration de Pelican
4. Choix d’un thème
5. Création du contenu du CV
6. Génération du site
7. Automatisation avec Makefile
8. Déploiement du site
9. Améliorations possibles
10. Ressources complémentaires

Autre atout : l’affichage de la chaîne de pensée dans la réponse. On voit clairement que le modèle hésite entre Pelican, Flask ou Hugo comme framework web, puis retient in fine la meilleure option.

Tutoriel OpenAI o1-preview : créer une application de classification de la qualité de l’eau

Dans ce projet, nous allons utiliser o1-preview pour construire et déployer une application de classification de la qualité de l’eau. Le cahier des charges est ambitieux, avec une description détaillée de nos attentes.

Si vous souhaitez réaliser un projet data science avec ChatGPT, consultez le guide pour utiliser ChatGPT dans vos projets data science. Vous y verrez comment l’exploiter pour la planification, l’analyse, le prétraitement, le choix de modèle, l’ajustement des hyperparamètres, la création d’une application web et son déploiement.

1. Conception du prompt

Nous allons passer du temps à peaufiner le prompt afin de fournir au modèle toutes les consignes du projet. 

Le prompt est divisé en trois parties :

1. Description du projet : une explication détaillée de l’objectif et de ce que nous voulons construire.
2. Objectifs et contraintes : préciser par exemple un objectif d’exactitude de 90 %.
3. Démarche à suivre : lister toutes les étapes : ingestion des données via l’API Kaggle, sauvegarde des métriques, analyse exploratoire, entraînement et évaluation du modèle, etc. Soyez exhaustif.

Lisez A Beginner's Guide to ChatGPT Prompt Engineering pour apprendre à rédiger des prompts efficaces dans ChatGPT. Le prompt engineering est un art, et avec l’arrivée de o1, il devient encore plus essentiel.

Prompt : « Mon chef de projet nous a confié le développement d’une application Water Quality à partir du jeu de données Kaggle disponible sur https://www.kaggle.com/datasets/adityakadiwal/water-potability. Fournissez toutes les informations nécessaires sur les fichiers, les packages Python et le code afin que nous puissions construire un modèle très précis.

L’objectif est d’atteindre 90 % d’exactitude globale.

Merci de suivre les étapes pour construire le projet :

1. Charger le jeu de données depuis Kaggle via l’API et le décompresser dans le dossier data.

2. Prétraiter les données et réaliser une analyse. Enregistrer les figures et fichiers d’analyse dans le dossier metrics.

3. Entraîner le modèle avec scikit-learn. Assurer le suivi des expériences et sauvegarder les fichiers de modèle et métadonnées. Sauvegarder le modèle avec la bibliothèque skops.

4. Effectuer une évaluation détaillée du modèle et enregistrer les résultats.

5. Créer une application FastAPI qui prend une saisie utilisateur et prédit la qualité de l’eau.

6. Ajouter l’interface utilisateur avec des templates Jinja2.

7. Déployer l’application sur le hub Hugging Face avec l’option Docker. »

La réponse générée nous fournit tout le nécessaire pour charger, prétraiter, entraîner et évaluer le modèle, créer l’application FastAPI, l’interface et la déployer. 

Problème : ces éléments sont éparpillés. Nous voulons que le modèle génère directement les fichiers Python et HTML à copier-coller.

Nous allons donc convertir tout le code en fichiers Python et HTML pour encore simplifier l’implémentation.

Prompt de relance : « Veuillez convertir le code en fichiers Python. » 

Nous obtenons alors une arborescence de projet avec tous les fichiers et leur code. Il ne reste qu’à créer les dossiers/fichiers et à coller le code.

2. Mise en place

Le modèle o1 fournit toutes les informations pour structurer le répertoire du projet. Il suffit de créer les dossiers et fichiers dans votre éditeur. 

Nous allons créer les dossiers suivants :

1. app : contiendra le fichier FastAPI et les templates HTML.
2. data : les données brutes et prétraitées.
3. metrics : les évaluations du modèle et les analyses exploratoires.
4. models : les modèles sauvegardés et objets de mise à l’échelle.
5. src : les fichiers Python pour charger, traiter, entraîner et évaluer.

Le répertoire racine contiendra également le Dockerfile, le README et le fichier requirements.txt.

3. Charger le jeu de données

Nous allons charger le jeu de données Kaggle Water Quality via l’API Kaggle et le décompresser dans le dossier data.

data\download_data.py :  

import os

# Ensure the data directory exists
os.makedirs("data", exist_ok=True)

# Download the dataset
os.system("kaggle datasets download -d adityakadiwal/water-potability -p data --unzip")

L’exécution du fichier Python télécharge le jeu de données, le dézippe et supprime l’archive. 

$ python .\src\download_data.py

Dataset URL: https://www.kaggle.com/datasets/adityakadiwal/water-potability
License(s): CC0-1.0
Downloading water-potability.zip to data
100%|████████████████████████████████████████████████████████████████████████████████| 251k/251k [00:00<00:00, 304kB/s]
100%|████████████████████████████████████████████████████████████████████████████████| 251k/251k [00:00<00:00, 303kB/s]

4. Prétraiter les données et réaliser l’analyse

Le script de prétraitement charge les données, les nettoie, gère les valeurs manquantes, effectue la mise à l’échelle, puis sauvegarde le scaler et le jeu de données prétraité. Il réalise également l’analyse et enregistre les métriques et visualisations.

data\preprocess_data.py :  

import os
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
import joblib

# Create directories if they don't exist
os.makedirs("metrics", exist_ok=True)
os.makedirs("models", exist_ok=True)

# Load the dataset
data = pd.read_csv("data/water_potability.csv")

# Check for missing values and save the summary
missing_values = data.isnull().sum()
missing_values.to_csv("metrics/missing_values.csv")

# Statistical summary
stats = data.describe()
stats.to_csv("metrics/data_statistics.csv")

# Pair plot
sns.pairplot(data, hue="Potability")
plt.savefig("metrics/pairplot.png")

# Correlation heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(data.corr(), annot=True)
plt.savefig("metrics/correlation_heatmap.png")

# Handle missing values
imputer = SimpleImputer(strategy="mean")
data_imputed = pd.DataFrame(imputer.fit_transform(data), columns=data.columns)

# Feature scaling
scaler = StandardScaler()
features = data_imputed.drop("Potability", axis=1)
target = data_imputed["Potability"]
features_scaled = scaler.fit_transform(features)

# Save the scaler
joblib.dump(scaler, "models/scaler.joblib")

# Save preprocessed data
preprocessed_data = pd.DataFrame(features_scaled, columns=features.columns)
preprocessed_data["Potability"] = target
preprocessed_data.to_csv("metrics/preprocessed_data.csv", index=False)

$ python .\src\preprocess_data.py 

Nous obtenons des données prétraitées et tous les rapports d’analyse accompagnés des figures. 

5. Création et entraînement du modèle

Le script d’entraînement charge les données prétraitées et entraîne un Random Forest Classifier. Skops est ensuite utilisé pour sauvegarder le modèle, assurer un suivi manuel de l’expérience et enregistrer des métadonnées au format JSON.

src\train_model.py :

import os
import json
import skops.io as sio
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# Load preprocessed data
data = pd.read_csv("metrics/preprocessed_data.csv")
features = data.drop("Potability", axis=1)
target = data["Potability"]

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    features, target, test_size=0.2, random_state=42, stratify=target
)

# Train the model
model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)

# Save the model using skops
os.makedirs("models", exist_ok=True)
sio.dump(model, "models/water_quality_model.skops")

# Track experiments and save metadata
metadata = {
    "model_name": "RandomForestClassifier",
    "parameters": model.get_params(),
    "training_score": model.score(X_train, y_train),
}

with open("models/metadata.json", "w") as f:
    json.dump(metadata, f, indent=4)

$ python .\src\train_model.py 

Le script génère un fichier de modèle et des métadonnées, comme ci-dessous.

6. Évaluation du modèle

Le script d’évaluation charge les données traitées et le modèle sauvegardé pour générer un rapport de classification, une matrice de confusion, la courbe ROC, l’AUC et l’exactitude globale. Toutes les métriques et figures sont enregistrées dans le dossier metrics.

src\evaluate_model.py :

import os
import json
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import (
    classification_report,
    confusion_matrix,
    roc_auc_score,
    roc_curve,
)
import skops.io as sio
from sklearn.model_selection import train_test_split

# Load preprocessed data
data = pd.read_csv("metrics/preprocessed_data.csv")
features = data.drop("Potability", axis=1)
target = data["Potability"]

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    features, target, test_size=0.2, random_state=42, stratify=target
)

# Load the model
model = sio.load("models/water_quality_model.skops")

# Predictions
y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test)[:, 1]

# Classification report
report = classification_report(y_test, y_pred, output_dict=True)
with open("metrics/classification_report.json", "w") as f:
    json.dump(report, f, indent=4)

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d")
plt.title("Confusion Matrix")
plt.ylabel("Actual Label")
plt.xlabel("Predicted Label")
plt.savefig("metrics/confusion_matrix.png")

# ROC curve and AUC
fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
roc_auc = roc_auc_score(y_test, y_pred_proba)

plt.figure()
plt.plot(fpr, tpr, label="AUC = %0.2f" % roc_auc)
plt.plot([0, 1], [0, 1], "k--")
plt.legend(loc="lower right")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("Receiver Operating Characteristic")
plt.savefig("metrics/roc_curve.png")

# Overall accuracy
accuracy = model.score(X_test, y_test)
print(f"Overall Accuracy: {accuracy * 100:.2f}%")

$ python .\src\evaluate_model.py  

L’exactitude globale n’est pas excellente. Nous pouvons toutefois demander au modèle o1 d’améliorer les performances.                                                      

Overall Accuracy: 65.55%

Le dossier metrics contient toutes les figures et métriques d’évaluation. Vous pouvez les passer en revue pour comprendre les performances en détail.

7. Créer une application FastAPI

Pour créer l’interface utilisateur de l’application FastAPI, nous allons créer les pages d’accueil et de résultat. Il suffit d’ajouter un dossier templates dans le répertoire app et deux fichiers HTML : la page principale et la page de résultats.

Consultez le tutoriel FastAPI : introduction à FastAPI pour maîtriser le framework et l’implémenter dans votre projet. 

Si vous n’êtes pas à l’aise avec HTML, pas d’inquiétude : copiez-collez simplement le code et faites confiance au modèle o1. 

app\templates\form.html :

<!DOCTYPE html>
<html>
<head>
    <title>Water Quality Prediction</title>
</head>
<body>
    <h2>Enter Water Parameters</h2>
    <form action="/predict" method="post">
        {% for feature in ['ph', 'Hardness', 'Solids', 'Chloramines', 'Sulfate', 'Conductivity', 'Organic_carbon', 'Trihalomethanes', 'Turbidity'] %}
        <label for="{{ feature }}">{{ feature.replace('_', ' ').title() }}:</label><br>
        <input type="number" step="any" id="{{ feature }}" name="{{ feature }}" required><br><br>
        {% endfor %}
        <input type="submit" value="Predict">
    </form>
</body>
</html>

app\templates\result.html :

<!DOCTYPE html>
<html>
<head>
    <title>Prediction Result</title>
</head>
<body>
    <h2>Prediction Result</h2>
    <p>The water is predicted to be: <strong>{{ result }}</strong></p>
    <a href="/">Try Again</a>
</body>
</html>

Le fichier Python principal définit deux fonctions : home et predict. La fonction « home » affiche la page d’accueil avec les champs de saisie et un bouton. La fonction « predict » transforme la saisie, la fait passer dans le modèle et renvoie si l’eau est potable ou non.

app\templates\main.py : 

from fastapi import FastAPI, Request, Form
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
import numpy as np
import skops.io as sio
import joblib

app = FastAPI()
templates = Jinja2Templates(directory="app/templates")

# Load the saved model and preprocessing pipeline
model = sio.load("models/water_quality_model.skops", trusted=True)
preprocessing_pipeline = joblib.load("models/preprocessing_pipeline.joblib")


@app.get("/", response_class=HTMLResponse)
async def home(request: Request):
    return templates.TemplateResponse("form.html", {"request": request})


@app.post("/predict", response_class=HTMLResponse)
async def predict(
    request: Request,
    ph: float = Form(...),
    Hardness: float = Form(...),
    Solids: float = Form(...),
    Chloramines: float = Form(...),
    Sulfate: float = Form(...),
    Conductivity: float = Form(...),
    Organic_carbon: float = Form(...),
    Trihalomethanes: float = Form(...),
    Turbidity: float = Form(...),
):
    input_data = np.array(
        [
            [
                ph,
                Hardness,
                Solids,
                Chloramines,
                Sulfate,
                Conductivity,
                Organic_carbon,
                Trihalomethanes,
                Turbidity,
            ]
        ]
    )
    # Preprocess input data
    input_preprocessed = preprocessing_pipeline.transform(input_data)
    prediction = model.predict(input_preprocessed)
    result = "Potable" if prediction[0] == 1 else "Not Potable"
    return templates.TemplateResponse(
        "result.html", {"request": request, "result": result}
    )

Nous allons tester l’application en local pour vérifier qu’elle tourne.

$ uvicorn app.main:app --reload 

En lançant le fichier Python avec uvicorn, nous obtenons l’adresse locale à copier-coller dans le navigateur. 

Remarque : toutes les indications pour exécuter les fichiers sont également fournies par le modèle o1.

INFO:     Will watch for changes in these directories: ['C:\\Repository\\GitHub\\Water-Quality-App']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [34792] using StatReload

Comme on le voit, l’appli fonctionne correctement. 

Saisissons des valeurs aléatoires pour tester la qualité de l’eau, puis cliquons sur Predict. 

Le résultat est sans appel : l’eau n’est pas potable.

Vous pouvez aussi accéder à la Swagger UI de FastAPI en ajoutant « /docs » à l’URL pour tester l’API et voir les résultats. 

8. Déployer l’application sur Hugging Face Hub avec Docker

Le modèle OpenAI o1 a généré le code Docker, un guide et des liens de référence pour déployer l’application sur Hugging Face.

Lisez le tutoriel Docker for Data Science : an introduction pour comprendre le fonctionnement de Docker : installation, commandes, dockerisation d’applications de ML et bonnes pratiques.

Créez d’abord un nouvel Espace : cliquez sur votre photo de profil sur Hugging Face puis sur « New Space ». Indiquez le nom, choisissez le type d’SDK (Docker), la licence et cliquez sur « Create Space ».

Source : Hugging Face

Toutes les instructions de déploiement avec Docker sont indiquées sur la page principale.

Source : Water Quality Classifier

Ensuite, clonez le dépôt.

git clone https://huggingface.co/spaces/kingabzpro/Water-Quality-Classifier

Dans le dépôt, déplacez les dossiers app et model. Créez un Dockerfile et saisissez la commande suivante. Le modèle o1 a fourni le code ; adaptez simplement le port à 7860.

Dockerfile :

# Use an official Python runtime as a parent image
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Expose port 7860
EXPOSE 7860

# Run the application
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Créez le fichier requirements.txt listant les packages Python. Il sera utilisé pour installer toutes les dépendances sur le serveur cloud.

requirements.txt :

fastapi
uvicorn
jinja2
pydantic
skops
joblib
numpy
pandas
scikit-learn==1.5.1
matplotlib
seaborn
kaggle
imbalanced-learn
python-multipart

Voici à quoi doit ressembler le dépôt de l’app :

Notre modèle dépasse 10 Mo : nous devons donc utiliser Git LFS pour le suivre. Installez Git LFS et suivez tous les fichiers « .skops ».

git lfs install
git lfs track "*.skops" 

Validez toutes les modifications et poussez-les vers le dépôt distant.

git add .
git commit -m "pushing all the files"
git push

Rendez-vous sur la page de votre application sur Hugging Face : la construction du conteneur et l’installation des packages vont démarrer. 

Source : Water Quality Classifier

Après quelques minutes, l’application est prête. Elle ressemble à la version locale. Renseignons des valeurs exemples pour générer un résultat. 

Source : Water Quality Classifier

Notre application fonctionne parfaitement et produit le résultat attendu.

Source : Water Quality Classifier

Cette Space Hugging Face est publique : on peut donc l’interroger avec la commande curl dans le terminal. 

curl -X 'POST' \
  'https://kingabzpro-water-quality-classifier.hf.space/predict' \
  -H 'accept: text/html' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'Organic_carbon=10&Hardness=200&Turbidity=4&Solids=10000&Chloramines=7&Trihalomethanes=80&Sulfate=300&ph=7&Conductivity=400' \
  | grep -oP '(?<=<strong>).*(?=</strong>)'

Sortie : 

Not Potable

Tous les fichiers du projet, données, modèles et métadonnées sont disponibles sur le dépôt GitHub kingabzpro/Water-Quality-App.

Avis de l’auteur

Conclusion

Dans ce tutoriel, nous avons vu à quel point le modèle de raisonnement o1 d’OpenAI est puissant. Nous avons construit un projet de machine learning complet avec quelques ajustements seulement, et il a fonctionné du premier coup. Le modèle a exécuté toutes les consignes parfaitement et a produit d’excellents résultats sans nécessiter de relances.

Nous avons aujourd’hui accès aux versions légères du modèle, comme o1-preview et o1-mini. À l’avenir, nous aurons accès au modèle o1 complet, encore plus adapté aux projets complexes. L’essentiel est de travailler la formulation des bonnes questions pour en tirer le meilleur.

Monter un projet de machine learning avec des modèles d’IA est à la portée de tous, mais pour en faire une carrière, il faut comprendre comment ces modèles fonctionnent. Sans cela, il est difficile de corriger les problèmes ou d’adapter les modèles à des besoins métiers spécifiques. Pour acquérir ces compétences, nous recommandons aux débutants le parcours Machine Learning Scientist with Python. Il comprend 21 cours et 3 projets pour apprendre à construire et améliorer différents types de modèles de machine learning.