OpenAI o1-preview-tutorial: een machinelearningproject bouwen

Aan de slag met o1-preview en o1-mini

Er zijn veel o1-modellen die gemakkelijk toegankelijk zijn, maar de officiële opties lopen via de OpenAI API of via een ChatGPT Plus- of Team-abonnement. 

In deze sectie leren we hoe we ze kunnen gebruiken om complexe problemen op te lossen.

Toegang tot het o1-model

Ben je bekend met de OpenAI API voor chatcompletion, stel dan de modelnaam in op "o1-preview" en geef een gedetailleerde prompt. Zo simpel is het.

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)

Om het in ChatGPT te gebruiken, klik je op de keuzelijst voor modelselectie en kies je het “o1-preview”-model, zoals hieronder te zien is.

Het o1-preview-model gebruiken in ChatGPT

De prompts voor het o1-model zijn anders. Je moet meerdere instructies of gedetailleerde vragen geven om de kracht volledig te benutten. Het kan een lange en complexe instructie verwerken om tot een optimaal antwoord te komen.

Belasting berekenen voor een freelancebedrijf in Europa kan complex zijn. We gebruiken het o1-model om onze belastingplicht aan de Spaanse overheid te bepalen.

Prompt: “Ik ben freelancer in Spanje en werk voor een Amerikaans bedrijf. Het afgelopen jaar heb ik 120.000 USD verdiend en ik moet uitrekenen hoeveel belasting ik verschuldigd ben. Houd er rekening mee dat ik 8 maanden geleden naar Spanje ben verhuisd.”

Het duurde bijna 30 seconden om te reageren, maar het antwoord was gedetailleerd. Het bevatte wiskundige vergelijkingen, belastinginformatie en alle nodige details om te bepalen hoeveel we de Spaanse overheid verschuldigd zijn.

Het antwoord was opgedeeld in de volgende onderdelen:

1. Bepaal je belastingresidentiestatus
2. Zet je inkomen om naar euro’s
3. Bereken je belastbaar inkomen
4. Bereken sociale zekerheidsbijdragen
5. Totaal geschatte verschuldigde belasting
6. Belangrijke opmerkingen
7. Volgende stappen

De samenvatting geeft een schatting van het verschuldigde bedrag, wat erg behulpzaam is. 

Je kunt in het chatantwoord op de uitklapoptie klikken om de chain of thought en de besluitvorming te bekijken. 

We zien dat het model de context, fiscale gevolgen en belastingschijven begrijpt voordat het je vraag beantwoordt.

Het o1-mini-model gebruiken in ChatGPT

Het o1-mini-model is minder nauwkeurig maar sneller dan o1-preview. In ons geval gebruiken we dit model om een statische website te maken voor data science-cv’s.

Prompt: “Maak alsjeblieft een statische website voor mijn data science-cv met behulp van een Python-framework.”

Het maakte niet alleen een goede cv-website, maar gaf ook uitleg over hoe je die gratis publiceert op GitHub Pages.

Het antwoord was opgedeeld in de volgende onderdelen:

1. Introductie tot Pelican
2. Vereisten
3. Pelican instellen
4. Thema kiezen
5. Je cv-inhoud maken
6. De site bouwen
7. Automatiseren met Makefile
8. Je cv-website deployen
9. Je cv-website uitbreiden
10. Aanvullende bronnen

Het is een fantastische functie dat de chain of thought in het antwoord wordt getoond. We zien duidelijk dat het model overweegt om Pelican, Flask of Hugo als webframework te gebruiken. Uiteindelijk heeft het de best mogelijke oplossing gekozen.

OpenAI o1-preview-tutorial: een applicatie voor waterkwaliteitsclassificatie bouwen

In dit project gebruiken we het o1-preview-model om een applicatie voor waterkwaliteitsclassificatie te bouwen en te deployen. Dit is best een complex project, want we geven een gedetailleerde beschrijving van wat we willen.

Ben je geïnteresseerd in het bouwen van een data science-project met ChatGPT, bekijk dan A Guide to Using ChatGPT for Data Science Projects. Je leert ChatGPT gebruiken voor projectplanning, data-analyse, gegevensvoorbewerking, modelselectie, hyperparametertuning, het ontwikkelen van een webapp en deployment.

1. Prompt engineering

We besteden extra tijd aan prompt engineering, omdat we willen zorgen dat alle projectinstructies aan het model worden meegegeven. 

De prompt is in drie delen opgesplitst:

1. Projectbeschrijving:  Een gedetailleerde uitleg van het project en wat we willen bouwen.
2. Doelen en beperkingen:  Geef de doelinformatie, zoals streven naar 90% nauwkeurigheid.  
3. Stappenplan: Geef alle stappen die het moet nemen. Bijvoorbeeld data-inname via de Kaggle API, metrics in de map opslaan, data-analyse uitvoeren, het model trainen en evalueren, en meer. Schrijf zoveel mogelijk stappen uit.

Lees A Beginner's Guide to ChatGPT Prompt Engineering om te leren hoe je goede prompts in ChatGPT schrijft en de gewenste resultaten genereert. Prompt engineering is een kunst, en met de introductie van het o1-model is het nog belangrijker geworden om te leren.

Prompt: “Mijn projectmanager heeft ons de taak gegeven om een Water Quality-applicatie te ontwikkelen met de Kaggle-dataset op https://www.kaggle.com/datasets/adityakadiwal/water-potability. Geef alle nodige informatie over de bestanden, Python-packages en code zodat we een zeer nauwkeurig model kunnen bouwen.

Het doel is om 90% algehele nauwkeurigheid te behalen. 

Volg deze stappen om het project te bouwen:

1. Laad de dataset van Kaggle met de API en pak deze uit in de data-map.

2. Preprocess de data en voer wat data-analyse uit. Sla de analysefiguren en -bestanden op in de metrics-map.

3. Train het model met het scikit-learn-framework. Zorg dat je de experimenten bijhoudt en de modelbestanden en metadata opslaat. Sla het model op met de skops-bibliotheek. 

4. Voer een gedetailleerde modelevaluatie uit en sla de resultaten op.

5. Maak een FastAPI-applicatie die een afbeelding van de gebruiker neemt en de waterkwaliteit voorspelt.

6. Zorg dat je de gebruikersinterface toevoegt met Jinja2-templates.

7. Deploy de app op de Hugging Face-hub met de Docker-optie.”

De gegenereerde respons gaf ons alle informatie die we nodig hebben om de data te laden, te preprocessen, het model te trainen en evalueren, de FastAPI-applicatie en een gebruikersinterface te maken en die te deployen. 

Het probleem is dat het gefragmenteerd is; we willen dat het Python- en HTML-bestanden voor ons maakt zodat we de code alleen nog hoeven te kopiëren en plakken.

We zetten nu alle code om naar Python- en HTML-bestanden, zodat het nog makkelijker wordt.

Vervolgprompt: “Zet de code alsjeblieft om naar Python-bestanden.” 

Zoals we zien, hebben we een projectstructuur met alle bestanden en code erin. We hoeven alleen mappen en bestanden aan te maken en de code te kopiëren en plakken.

2. Inrichten

Het o1-model geeft alle informatie die nodig is om een projectdirectory in te richten. We hoeven alleen mappen en bestanden in de projectmap aan te maken met de code-editor. 

We maken de volgende mappen aan:

1. app: deze map bevat het app-bestand voor FastAPI en HTML-templates.
2. data: deze map bevat de originele en de voorbewerkte data.
3. metrics: deze map bevat modelevaluatiedata en data-analyse.
4. models: deze map bevat opgeslagen modellen en scaler-objecten.
5. src: deze map bevat alle Python-bestanden voor laden, verwerken, trainen en evalueren.

Daarnaast bevat de hoofdmap het Dockerfile, de README en het bestand requirements.txt.

3. De dataset laden

We laden de Water Quality-Kaggle-dataset met de Kaggle API en pakken die uit in de data-map.

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

Het uitvoeren van het Python-bestand downloadt de dataset, pakt die uit en verwijdert het zipbestand. 

$ 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. Data preprocessen en data-analyse uitvoeren

Het preprocessing-Pythonbestand laadt de data, maakt deze schoon, gaat om met missende waarden, schaalt de data en slaat vervolgens de scaler en de voorbewerkte dataset op. Ook voert het data-analyse uit en slaat het de metrics en datavisualisaties op.

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 

We hebben voorbewerkte data en alle data-analyserapporten met figuren gekregen. 

5. Model bouwen en trainen

Het trainingsscript laadt de voorbewerkte data en traint er een Random Forest Classifier op. Vervolgens wordt Skope gebruikt om het model op te slaan, het experiment handmatig te tracken en de modelmetadata als JSON op te slaan.

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 

Het trainingsscript genereert een modelbestand en metadata, zoals hieronder te zien is.

6. Modelevaluatie

Het modelevaluatiescript laadt de verwerkte data en het opgeslagen model om een classificatierapport, verwarringsmatrix, ROC-curve, AUC en algehele nauwkeurigheid te genereren. Alle metrics en figuren worden opgeslagen in de metrics-map.

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  

De algehele nauwkeurigheid is niet zo goed. We kunnen het o1-model echter altijd vragen de nauwkeurigheid te verbeteren.                                                      

Overall Accuracy: 65.55%

De metrics-map bevat alle opgeslagen modelevaluatiefiguren en -metrics. We kunnen die handmatig bekijken om de modelprestaties in detail te begrijpen.

7. Een FastAPI-applicatie maken

Voor de gebruikersinterface van de FastAPI-app moeten we de index- en resultaatpagina’s maken. Dit kan door in de app-map een template-map te maken en twee HTML-bestanden toe te voegen: één voor de hoofdpagina en één voor de resultatenpagina.

Bekijk de FastAPI Tutorial: An Introduction to Using FastAPI om in detail te leren over het FastAPI-framework en hoe je het in je project toepast. 

Ben je niet bekend met HTML, geen zorgen. Je hoeft de code alleen te kopiëren en plakken en te vertrouwen op het o1-model. 

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>

Het hoofd-Pythonbestand van de applicatie heeft twee Python-functies: home en predict. De functie "home" toont de welkomstpagina met invoervelden en een knop. De functie "predict" zet gebruikersinvoer om, voert die door het model en toont het resultaat dat aangeeft of het water drinkbaar is of niet.

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

We testen de app eerst lokaal om te controleren of hij draait.

$ uvicorn app.main:app --reload 

Door het Python-bestand te draaien met uvicorn krijgen we het lokale adres dat we kunnen kopiëren en in de browser plakken. 

Opmerking: alle informatie over het uitvoeren van de bestanden wordt ook door het o1-model gegeven.

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

Zoals we zien werkt de app prima. 

Laten we willekeurige waarden invoeren om de waterkwaliteit te controleren en op de predict-knop drukken. 

Het resultaat is overtuigend. Het laat zien dat het water niet drinkbaar is.

Je kunt zelfs de FastAPI Swagger UI openen door “/docs” achter de URL te typen om de API te testen en resultaten te genereren. 

8. De app deployen op Hugging Face Hub met Docker

Het OpenAI o1-model heeft de Docker-code, een handleiding en referentielinks gegenereerd zodat we succesvol leren hoe we de applicatie op Hugging Face deployen.

Lees de tutorial Docker for Data Science: An Introduction om te leren hoe Docker werkt. Je leert Docker instellen, Docker-commando’s gebruiken, machinelearningapplicaties dockerizen en best practices volgen.

Maak eerst een nieuwe Space aan door op je profielfoto op de Hugging Face-website te klikken en daarna op de knop "New Space". Typ de appnaam, kies het SDK-type (Docker), kies het licentietype en klik op “Create Space”.

Bron: Hugging Face

Alle instructies om de app met Docker te deployen staan op de hoofdpagina.

Bron: Water Quality Classifier

Vervolgens moeten we de repository clonen.

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

Plaats binnen de repository de app- en modelmappen. Maak een Dockerfile en typ het volgende commando. Het o1-model heeft de code gegeven; we hoeven alleen het poortnummer te wijzigen naar 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"]

Maak het bestand requirements.txt met informatie over de Python-packages. We gebruiken dit bestand om alle vereiste Python-packages op de cloudserver te downloaden en te installeren.

requirements.txt:

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

Zo zou onze app-repository eruit moeten zien:

Ons model is een groot bestand (> 10MB), dus we moeten Git LFS gebruiken om het te tracken. Installeer Git LFS en track alle bestanden met de extensie “.skops”.

git lfs install
git lfs track "*.skops" 

Stage alle wijzigingen, commit met een bericht en push naar de remote server.

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

Ga naar de app-pagina op Hugging Face en je ziet dat de container wordt gebouwd en alle benodigde packages worden geïnstalleerd. 

Bron: Water Quality Classifier

Na een paar minuten is de app klaar voor gebruik. Hij lijkt op de lokale app. Laten we voorbeeldwaarden invullen en resultaten genereren. 

Bron: Water Quality Classifier

Onze app werkt perfect en levert de verwachte resultaten op.

Bron: Water Quality Classifier

Deze Hugging Face Space-app is voor iedereen beschikbaar, wat betekent dat we er met het curl-commando in de terminal toegang toe hebben. 

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

Output: 

Not Potable

Alle projectbestanden, data, modellen en metadata zijn beschikbaar in de kingabzpro/Water-Quality-App-GitHub-repository.

Mening van de auteur

Conclusie

In deze tutorial hebben we gezien hoe krachtig het o1-reasoningmodel van OpenAI kan zijn. We hebben een volledig machinelearningproject gebouwd met slechts een paar kleine codewijzigingen, en het werkte meteen. Het model voerde elke opdracht perfect uit en leverde uitstekende resultaten zonder vervolgvragen nodig te hebben.

Op dit moment hebben we toegang tot de kleinere versies van het o1-model, zoals o1-preview en o1-mini. In de toekomst krijgen we toegang tot het volledige o1-model, dat nog beter zal zijn voor het bouwen van complexe projecten. De sleutel is om te werken aan het stellen van de juiste vragen om het meeste uit het model te halen.

Een machinelearningproject bouwen met AI-modellen is eenvoudig, maar als je er je carrière van wilt maken, moet je begrijpen hoe deze modellen werken. Zonder dat inzicht is het lastig om problemen op te lossen of de modellen toe te passen op specifieke bedrijfsbehoeften. Voor dat begrip raden we beginners aan om de Machine Learning Scientist with Python-careertrack te volgen. Die bevat 21 cursussen en 3 projecten om je te leren hoe je verschillende soorten machinelearningmodellen bouwt en verbetert.