Tutorial OpenAI o1-preview: crea un progetto di machine learning

Primi passi con o1-preview e o1-mini

Esistono molti modelli o1 facilmente accessibili, ma quelli ufficiali sono disponibili tramite l'API di OpenAI o con l'abbonamento ChatGPT Plus o Team. 

In questa sezione vedremo come usarli per risolvere problemi complessi.

Accedere al modello o1

Se conosci l'API di OpenAI per le chat completion, ti basta impostare il nome del modello su "o1-preview" e fornire un prompt dettagliato. È tutto qui.

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)

Per accedervi su ChatGPT, devi cliccare sul menu a tendina di selezione del modello e scegliere il modello “o1-preview”, come mostrato qui sotto.

Usare il modello o1-preview in ChatGPT

I prompt del modello o1 sono diversi. Devi fornirgli più istruzioni o domande dettagliate per sfruttarne appieno la potenza. Può gestire istruzioni lunghe e complesse per generare una risposta ottimale.

Calcolare le tasse per un'attività da freelance in Europa può essere complesso. Useremo il modello o1 per determinare la nostra imposta dovuta al governo spagnolo.

Prompt: “Sono un freelance in Spagna che lavora per un'azienda con sede negli Stati Uniti. Nell'ultimo anno ho guadagnato 120.000 USD e devo calcolare le tasse dovute. Tieni conto che mi sono trasferito in Spagna 8 mesi fa.”

Ci sono voluti quasi 30 secondi per rispondere, ma la risposta è stata dettagliata. Includeva equazioni matematiche, informazioni fiscali e tutti i dettagli necessari per determinare quanto dobbiamo al governo spagnolo.

La risposta è stata suddivisa nelle seguenti parti:

1. Determina il tuo stato di residenza fiscale
2. Converti il tuo reddito in euro
3. Calcola il tuo reddito imponibile
4. Calcola i contributi previdenziali
5. Tasse totali stimate dovute
6. Note importanti
7. Passi successivi

Rivedendo la sezione di riepilogo otteniamo l'importo approssimativo delle tasse dovute, il che è molto utile. 

Puoi cliccare sul menu a discesa nella risposta della chat per vedere la catena di ragionamenti e il processo decisionale. 

Vediamo che il modello comprende il contesto, le implicazioni fiscali e lo scaglione di imposta prima di rispondere alla tua domanda.

Usare il modello o1-mini in ChatGPT

Il modello o1-mini è meno accurato ma più veloce di o1-preview. Nel nostro caso, lo useremo per creare un sito statico per CV di data science.

Prompt: “Per favore crea un sito statico per il mio CV di data science usando un framework Python.”

Non solo ha creato un sito CV ben fatto, ma ci ha anche fornito indicazioni su come pubblicarlo gratuitamente su GitHub Pages.

La risposta è stata suddivisa nelle seguenti parti:

1. Introduzione a Pelican
2. Prerequisiti
3. Configurazione di Pelican
4. Scelta di un tema
5. Creazione dei contenuti del tuo CV
6. Build del sito
7. Automazione con Makefile
8. Deploy del tuo sito CV
9. Migliorare il tuo sito CV
10. Risorse aggiuntive

La possibilità di mostrare la catena di ragionamenti nella risposta è fantastica. Possiamo vedere chiaramente che il modello sta valutando l'uso di Pelican, Flask o Hugo come framework web. Alla fine, ha selezionato la soluzione migliore possibile.

Tutorial OpenAI o1-preview: costruire un'applicazione di classificazione della qualità dell'acqua

In questo progetto useremo il modello o1-preview per costruire e distribuire un'applicazione di classificazione della qualità dell'acqua. È un progetto piuttosto complesso, perché forniremo una descrizione dettagliata di ciò che cerchiamo.

Se ti interessa costruire un progetto di data science usando ChatGPT, dai un'occhiata a Una guida all'uso di ChatGPT per progetti di data science. Imparerai a usare ChatGPT per pianificazione del progetto, analisi dei dati, preprocessing, selezione del modello, tuning degli iperparametri, sviluppo di una web app e deploy.

1. Prompt engineering

Dedicheremo più tempo al prompt engineering, perché vogliamo assicurarci che tutte le direttive di progetto siano fornite al modello. 

Il prompt è diviso in tre parti:

1. Descrizione del progetto: spiegazione dettagliata del progetto e di ciò che vogliamo costruire.
2. Obiettivi e vincoli: fornisci informazioni sull'obiettivo, ad esempio puntare al 90% di accuratezza.  
3. Passi da seguire: elenca tutti i passaggi necessari che vuoi che segua. Per esempio, ingestione dei dati usando la Kaggle API, salvataggio delle metriche nella cartella, analisi dei dati, training e valutazione del modello e altro. Scrivi più passaggi possibile.

Leggi Guida per principianti al prompt engineering in ChatGPT per imparare a scrivere prompt efficaci in ChatGPT e ottenere i risultati richiesti. Il prompt engineering è un'arte e, con l'introduzione del modello o1, è diventato ancora più importante da apprendere.

Prompt: “Il mio project manager ci ha incaricati di sviluppare un'applicazione Water Quality usando il dataset Kaggle disponibile su https://www.kaggle.com/datasets/adityakadiwal/water-potability. Fornisci tutte le informazioni necessarie su file, pacchetti Python e codice così da costruire un modello altamente accurato.

L'obiettivo è raggiungere il 90% di accuratezza complessiva. 

Segui questi passaggi per costruire il progetto:

1. Carica il dataset da Kaggle usando l'API e decomprimilo nella cartella data.

2. Preprocessa i dati ed esegui un'analisi esplorativa. Salva le figure e i file dell'analisi nella cartella metrics.

3. Allena il modello usando il framework scikit-learn. Assicurati di tracciare gli esperimenti e di salvare i file del modello e i metadati. Salva il modello usando la libreria skops. 

4. Esegui una valutazione dettagliata del modello e salva i risultati.

5. Crea un'applicazione FastAPI che riceve un'immagine dall'utente e predice la qualità dell'acqua.

6. Assicurati di aggiungere l'interfaccia utente usando i template Jinja2.

7. Effettua il deploy dell'app su Hugging Face hub usando l'opzione Docker.”

La risposta generata ci ha fornito tutte le informazioni necessarie per caricare i dati, preprocessarli, allenare e valutare il modello, creare l'applicazione FastAPI, creare un'interfaccia utente ed effettuare il deploy. 

Il problema è che è frammentata e vogliamo che crei per noi i file Python e HTML in modo da poter semplicemente copiare e incollare il codice.

Convertiremo ora tutto il codice in file Python e HTML, rendendoci la vita ancora più semplice.

Prompt di follow-up: “Per favore converti il codice in file Python.” 

Come possiamo vedere, abbiamo una struttura di progetto con tutti i file e il codice al suo interno. Non dobbiamo far altro che creare cartelle e file e copiare e incollare il codice.

2. Configurazione

Il modello o1 fornisce tutte le informazioni necessarie per configurare una directory di progetto. Dobbiamo semplicemente creare cartelle e file all'interno della directory usando l'editor di codice. 

Creeremo le seguenti cartelle:

1. app: questa cartella conterrà il file dell'app FastAPI e i template HTML.
2. data: questa cartella conterrà i dati originali e i dati pre-processati.
3. metrics: questa cartella conterrà i dati di valutazione del modello e l'analisi dei dati.
4. models: questa cartella conterrà i modelli salvati e gli oggetti scaler.
5. src: questa cartella conterrà tutti i file Python che ci aiuteranno in caricamento, elaborazione, training e valutazione.

Inoltre, la directory principale conterrà il Dockerfile, il README e il file requirements.txt.

3. Caricare il dataset

Caricheremo il dataset Water Quality da Kaggle usando la Kaggle API e lo decomprimeremo nella cartella 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'esecuzione del file Python scaricherà il dataset, lo decomprimerà e rimuoverà il file zip. 

$ 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. Preprocessare i dati ed effettuare l'analisi

Lo script di preprocessing carica i dati, li pulisce, gestisce i valori mancanti, li scala e poi salva lo scaler e il dataset preprocessato. Esegue anche l'analisi dei dati e salva metriche e visualizzazioni.

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 

Abbiamo ottenuto i dati preprocessati e tutti i report di analisi con le figure. 

5. Costruzione e training del modello

Lo script di training carica i dati preprocessati e li usa per addestrare un Random Forest Classifier. Skope viene poi usato per salvare il modello, tracciare manualmente l'esperimento e salvare i metadati del modello come file 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 

Lo script di training genererà un file modello e i metadati, come mostrato di seguito.

6. Valutazione del modello

Lo script di valutazione carica i dati processati e il modello salvato per generare report di classificazione, matrice di confusione, curva ROC, AUC e accuratezza complessiva. Tutte le metriche e le figure vengono salvate nella cartella 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'accuratezza complessiva non è granché. Tuttavia, possiamo sempre chiedere al modello o1 di migliorarla.                                                      

Overall Accuracy: 65.55%

La cartella metrics contiene tutte le figure e le metriche di valutazione del modello salvate. Possiamo rivederle manualmente per capire nel dettaglio le prestazioni del modello.

7. Creare un'applicazione FastAPI

Per creare un'interfaccia utente per l'app FastAPI, dobbiamo creare le pagine index e result. Possiamo farlo creando una cartella template all'interno della directory app e aggiungendo due file HTML: uno per la pagina principale e uno per la pagina dei risultati.

Dai un'occhiata al tutorial FastAPI: introduzione a FastAPI per imparare in dettaglio il framework FastAPI e come implementarlo nel tuo progetto. 

Se non conosci l'HTML, non preoccuparti. Devi solo copiare e incollare il codice e fidarti del modello 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>

Il file Python principale dell'applicazione ha due funzioni: home e predict. La funzione "home" mostra la pagina di benvenuto con i campi di input e un pulsante. La funzione "predict" trasforma l'input dell'utente, lo passa al modello e mostra il risultato che indica se l'acqua è potabile o meno.

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

Testeremo prima l'app in locale per verificare che sia in esecuzione.

$ uvicorn app.main:app --reload 

Eseguendo il file Python con uvicorn, otteniamo l'indirizzo locale che possiamo copiare e incollare nel browser. 

Nota: tutte le informazioni su come eseguire i file sono fornite anche dal modello 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

Come possiamo vedere, l'app funziona correttamente. 

Forniamole ora dei valori casuali per verificare la qualità dell'acqua e premiamo il pulsante predict. 

Il risultato è ottimo. Mostra che l'acqua non è potabile.

Puoi anche accedere alla Swagger UI di FastAPI digitando “/docs” dopo l'URL per testare l'API e generare i risultati. 

8. Effettuare il deploy dell'app su Hugging Face Hub con Docker

Il modello OpenAI o1 ha generato il codice Docker, una guida e link di riferimento per permetterci di imparare con successo come distribuire l'applicazione su Hugging Face.

Leggi il tutorial Docker per la Data Science: un'introduzione per capire come funziona Docker. Imparerai a configurare Docker, usare i comandi Docker, containerizzare applicazioni di machine learning e seguire best practice diffuse nel settore.

Per prima cosa, crea una nuova Space cliccando sull'immagine del profilo sul sito di Hugging Face e poi sul pulsante "New Space". Inserisci il nome dell'app, seleziona il tipo di SDK (Docker), scegli la licenza e premi “Create Space”.

Fonte: Hugging Face

Tutte le istruzioni per effettuare il deploy dell'app con Docker sono fornite nella pagina principale.

Fonte: Water Quality Classifier

Successivamente, dobbiamo clonare il repository.

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

All'interno del repository, sposta le cartelle app e model. Crea un Dockerfile e inserisci il seguente comando. Il modello o1 ci ha fornito il codice; dobbiamo solo cambiare il numero di porta in 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"]

Crea il file requirements.txt con le informazioni sui pacchetti Python. Useremo questo file per scaricare e installare tutti i pacchetti necessari sul server cloud.

requirements.txt:

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

Ecco come dovrebbe apparire il repository della nostra app:

Il nostro modello è un file di grandi dimensioni (> 10MB), quindi dobbiamo usare Git LFS per tracciarlo. Installa Git LFS e traccia tutti i file con estensione “.skops”.

git lfs install
git lfs track "*.skops" 

Metti in stage tutte le modifiche, esegui il commit con un messaggio e fai push sul server remoto.

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

Vai alla pagina della tua app su Hugging Face: vedrai che sta costruendo il container e installando tutti i pacchetti necessari. 

Fonte: Water Quality Classifier

Dopo alcuni minuti, l'app sarà pronta all'uso. È simile all'app locale. Proviamo a fornirle dei valori di esempio e generare i risultati. 

Fonte: Water Quality Classifier

La nostra app funziona perfettamente e ha prodotto i risultati attesi.

Fonte: Water Quality Classifier

Questa Space su Hugging Face è disponibile a chiunque, quindi possiamo accedervi usando il comando curl nel terminale. 

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

Tutti i file del progetto, i dati, i modelli e i metadati sono disponibili nel repository GitHub kingabzpro/Water-Quality-App.

Opinione dell'autore

Conclusione

In questo tutorial abbiamo visto quanto possa essere potente il modello di ragionamento o1 di OpenAI. Abbiamo costruito un progetto completo di machine learning con poche modifiche al codice ed è funzionato subito. Il modello ha gestito ogni comando alla perfezione e ha prodotto ottimi risultati senza bisogno di istruzioni successive.

Al momento abbiamo accesso alle versioni più piccole del modello o1, come o1-preview e o1-mini. In futuro avremo accesso al modello o1 completo, che sarà ancora migliore per costruire progetti complessi. La chiave è lavorare sul porre le domande giuste per ottenere il massimo dal modello.

Costruire un progetto di machine learning con i modelli di AI è semplice, ma se vuoi farne una carriera devi capire come funzionano questi modelli. Senza questa comprensione, può essere difficile risolvere problemi o applicare i modelli a esigenze di business specifiche. Per acquisire questa comprensione, consigliamo ai principianti il career track Machine Learning Scientist with Python. Include 21 corsi e 3 progetti per insegnarti a costruire e migliorare diversi tipi di modelli di machine learning.