Tutoriel Openai O1-Preview: Construire un projet d'apprentissage automatique

Dans ce tutoriel, nous créerons une application de classificateur de qualité de l'eau à partir de zéro et la déployerons dans le cloud à l'aide de Docker. 

Nous allons commencer par explorer le modèle OpenAI O1 et comprendre sa fonctionnalité. Nous allons ensuite accéder au modèle via API et Chatgpt, expérimentant à la fois les versions O1-Preview et O1-MinI, avant de développer des invites efficaces pour construire une application de classificateur de qualité de l'eau. 

Une fois que nous aurons la sortie, nous ajouterons le code et les fichiers fournis par le modèle O1 dans le dossier du projet, puis charger, prétraiter, former et évaluer en exécutant le code Python localement. Enfin, nous allons créer une application FastAPI et la déployer sur le visage étreint en utilisant Docker.

Si vous êtes nouveau dans l'IA, la piste de compétences fondamentales de l'IA est un excellent point de départ. Il vous aidera à découvrir des sujets d'IA populaires comme Chatgpt et de grands modèles de langue. 

Image par auteur

En démarrage avec O1-Preview et O1-MinI

Il existe de nombreux modèles O1 faciles à accès, mais les officiels sont soit via l'API OpenAI, soit en utilisant le chatppt Plus ou l'abonnement d'équipe. 

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

Accéder au modèle O1

Si vous connaissez l'API OpenAI pour l'achèvement du chat, vous devez définir le nom du modèle sur "O1-Preview" et fournir une invite détaillée. C'est aussi simple.

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)

Pour y accéder sur Chatgpt, vous devez cliquer sur l'option déroulante de sélection du modèle et sélectionner le modèle "O1-Preview", comme indiqué ci-dessous.

Utilisation du modèle O1-Preview dans Chatgpt

Les invites du modèle O1 sont différentes. Vous devez lui fournir plusieurs instructions ou des questions détaillées pour réaliser pleinement son pouvoir. Il peut prendre une instruction longue et complexe pour générer une réponse optimale.

Le calcul des taxes pour une entreprise indépendante en Europe peut être complexe. Nous utiliserons le modèle O1 pour déterminer notre responsabilité fiscale envers le gouvernement espagnol.

Invite: « Je suis un pigiste en Espagne travaillant pour une entreprise basée aux États-Unis. Au cours de la dernière année, j'ai gagné 120 000 USD et je dois calculer le montant des taxes que je dois. Veuillez prendre en compte que j'ai déménagé en Espagne il y a 8 mois. ”

Il a fallu près de 30 secondes pour répondre, mais la réponse a été détaillée. Il comprenait des équations mathématiques, des informations fiscales et tous les détails nécessaires pour déterminer combien nous devons le gouvernement espagnol.

La réponse a été divisée en parties suivantes:

1. Déterminez votre statut de résidence fiscale
2. Convertir vos revenus en euros
3. Calculez votre revenu imposable
4. Calculer les contributions de la sécurité sociale
5. Les taxes estimées totales dues
6. Notes importantes
7. Étapes suivantes

La révision de la section récapitulative nous fournit le montant approximatif de l'impôt dû au gouvernement, ce qui est très utile. 

Vous pouvez cliquer sur le menu déroulant dans la réponse de chat pour afficher la chaîne de pensée et la prise de décision. 

Nous pouvons voir que le modèle comprend son contexte, les implications fiscales et la tranche d'imposition avant de répondre à votre question.

Utilisation du modèle O1-MinI dans Chatgpt

Le modèle O1-MINI est moins précis mais plus rapide que le modèle O1-Preview. Dans notre cas, nous utiliserons ce modèle pour créer un site Web statique pour les curriculum vitae de la science des données.

Invite: " Veuillez créer un site Web statique pour mon CV de science des données à l'aide d'un framework Python."

non seulement il a créé un site Web de CV approprié, mais il nous a également fourni des conseils sur la façon de le publier gratuitement sur les pages GitHub.

La réponse a été divisée en parties suivantes:

1. Introduction à Pelican
2. Prérequis
3. Configuration de Pelican
4. Choisir un thème
5. Création de votre contenu de CV
6. Construire le site
7. Automatisation avec MakeFile
8. Déployer votre site Web de CV
9. Améliorer votre site Web de CV
10. Ressources supplémentaires

C'est une fonctionnalité fantastique pour afficher la chaîne de pensée dans la réponse. Nous pouvons clairement voir que le modèle envisage d'utiliser Pélican, Flask ou Hugo comme cadre Web. En fin de compte, il a sélectionné la meilleure solution possible.

Tutoriel Openai O1-Preview: Construire une application de classificateur de qualité de l'eau

Dans ce projet, nous utiliserons le modèle O1-Preview pour construire et déployer une application de classification de la qualité de l'eau. Il s'agit d'un projet assez complexe, car nous lui fournirons une description détaillée de ce que nous recherchons.

Si vous êtes intéressé à créer un projet de science des données à l'aide de Chatgpt, consultez un guide pour utiliser les projets de science des données. Vous apprendrez à utiliser le chatppt pour la planification de projet, l'analyse des données, le prétraitement des données, la sélection du modèle, le réglage de l'hyperparamètre, le développement d'une application Web et le déploiement.

1. Ingénierie rapide

Nous passerons plus de temps en ingénierie rapide, car nous voulons nous assurer que toutes les directives de projet sont fournies au modèle. 

L'invite est divisée en trois parties:

1. DESCRIPTION DU PROJET: Une explication détaillée du projet et de ce que nous voulons construire.
2. Objectifs et restrictions: Fournir les informations sur l'objectif, telles que la vision de la précision de 90%.  
3. étapes à suivre: Fournissez toutes les étapes nécessaires que vous souhaitez qu'elle prenne. Par exemple, l'ingestion de données à l'aide de l'API Kaggle, enregistrant des mesures dans le dossier, effectuant l'analyse des données, la formation et l'évaluation du modèle, etc. Écrivez autant d'étapes que possible.

Lisez le guide d'un débutant pour le chat de l'ingénierie invite pour apprendre à rédiger des invites appropriées dans le chatgpt et à générer les résultats requis. L'ingénierie rapide est un art, et avec l'introduction du modèle O1, est devenu plus nécessaire pour apprendre.

Invite: «Mon chef de projet nous a chargés de développer une application de qualité de l'eau à l'aide de l'ensemble de données Kaggle disponible sur https://www.kaggle.com/datasets/adityakadiwal/water-potabilité. Veuillez fournir toutes les informations nécessaires sur les fichiers, les packages Python et le code afin que nous puissions créer un modèle très précis.

L'objectif est d'atteindre une précision globale de 90%. 

Veuillez suivre les étapes pour construire le projet:

1. Chargez l'ensemble de données à partir de Kaggle à l'aide de l'API et dézippez-le dans le dossier de données.

2. Prétraitez les données et effectuez une analyse des données. Enregistrez les chiffres et fichiers d'analyse dans le dossier de métriques.

3. Former le modèle à l'aide du cadre Scikit-Learn. Assurez-vous de suivre les expériences et d'enregistrer les fichiers et les métadonnées du modèle. Enregistrez le modèle à l'aide de la bibliothèque Skops. 

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

5. Créez une application Fastapi qui prend une image de l'utilisateur et prédit la qualité de l'eau.

6. Assurez-vous d'ajouter l'interface utilisateur à l'aide de modèles Jinja2.

7. Déployez l'application sur le centre de face étreint à l'aide de l'option Docker. »

La réponse générée nous a fourni toutes les informations dont nous avons besoin pour charger les données, le prétraiter, former et évaluer le modèle, créer l'application FastAPI, créer une interface utilisateur et les déployer. 

Le problème est qu'il est fragmenté et que nous voulons qu'il crée des fichiers Python et HTML pour que nous puissions simplement copier et coller le code.

Nous allons désormais convertir tout le code en fichiers Python et HTML, ce qui nous facilite encore la vie.

Invite de suivi: «Veuillez convertir le code en fichiers Python.» 

Comme nous pouvons le voir, nous avons une structure de projet avec tous les fichiers et le code. Tout ce que nous avons à faire est de créer des dossiers et des fichiers et copier et coller le code.

2. Configuration

Le modèle O1 fournit toutes les informations nécessaires pour configurer un répertoire de projet. Nous devons simplement créer des dossiers et des fichiers dans le répertoire du projet à l'aide de l'éditeur de code. 

Nous créerons les dossiers suivants:

1. APP: Ce dossier contiendra le fichier d'application pour les modèles FastAPI et HTML.
2. Données: ce dossier contiendra les données d'origine et les données prétraitées.
3. Métriques: ce dossier contiendra des données d'évaluation des modèles et une analyse des données.
4. Modèles: Ce dossier contiendra des modèles enregistrés et des objets SCALER.
5. SRC: Ce dossier contiendra tous les fichiers Python qui nous aideront à charger, le traitement, la formation et l'évaluation.

De plus, le répertoire principal contiendra le fichier dockerfile, readme et exigences.txt.

3. Chargez l'ensemble de données

Nous allons charger l'ensemble de données Kaggle de qualité de l'eau à l'aide de l'API Kaggle et les décompresser dans le dossier de données.

datadownload_data.py:

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)

L'exécution du fichier Python téléchargera l'ensemble de données, la décomposera et supprimera le fichier zip. 

$ python .srcdownload_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")

4. Prétraitez les données et effectuez l'analyse des données

Le fichier Python de prétraitement chargera les données, les nettoiera, gérera les données manquantes, les mettra à l'échelle, puis enregistrera l'échelle et l'ensemble de données prétraité. Il effectuera également l'analyse des données et enregistrera les métriques et la visualisation des données.

datapreprocess_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]

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)

Nous avons reçu des données prétraitées et tous les rapports d'analyse des données avec des chiffres. 

5. Modèle de construction et de formation

Le script d'entraînement charge les données prétraitées et les utilise pour former un classificateur de forêt aléatoire. Skope est ensuite utilisé pour enregistrer le modèle, suivre l'expérience manuellement et enregistrer les métadonnées du modèle en tant que fichier JSON.

srctrain_model.py:

$ python .\src\preprocess_data.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)

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

6. Évaluation du modèle

Le script d'évaluation du modèle charge les données traitées et le modèle enregistré pour générer un rapport de classification, une matrice de confusion, une courbe ROC, une ASC et une précision globale. Toutes les métriques et chiffres sont enregistrées dans le dossier de métriques.

srcevaluate_model.py:

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)

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

La précision globale n'est pas si bonne. Cependant, nous pouvons toujours demander au modèle O1 d'améliorer la précision.                                                      

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]

Le dossier de métriques contient toutes les figures d'évaluation et les métriques enregistrées enregistrées. Nous pouvons le revoir manuellement pour comprendre les performances du modèle en détail.

7. Créer une application FastAPI

Pour créer une interface utilisateur pour l'application FastAPI, nous devons créer les pages d'index et de résultats. Cela peut être fait en créant un dossier de modèle dans le répertoire de l'APP et en ajoutant deux fichiers HTML: un pour la page principale et un pour la page de résultats.

Consultez le tutoriel Fastapi: une introduction à l'utilisation de Fastapi pour en savoir plus sur le framework Fastapi et comment vous pouvez le mettre en œuvre dans votre projet. 

Si vous n'êtes pas familier avec HTML, ne vous inquiétez pas. Il vous suffit de copier et de coller le code et de faire confiance au modèle O1. 

apptemplateform.html:

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)

apptemplateResult.html:

$ python .\src\preprocess_data.py 

Le fichier Python de l'application principale a deux fonctions Python: la maison et la prévision. La fonction "Accueil" affiche la page de bienvenue contenant des boîtes d'entrée et un bouton. La fonction "prédire" transforme l'entrée utilisateur, l'exécute via le modèle et affiche le résultat indiquant si l'eau est potable ou non.

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

Nous testerons d'abord l'application localement pour vérifier si elle s'exécute.

$ python .\src\train_model.py 

En exécutant le fichier Python à l'aide d'Uvicorn, nous obtenons l'adresse locale qui peut être copiée et collée dans notre navigateur. 

Remarque: toutes les informations sur la façon d'exécuter les fichiers sont également fournies par le modèle O1.

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

Comme nous pouvons le voir, l'application fonctionne bien. 

Fournit-le les valeurs aléatoires pour vérifier la qualité de l'eau et appuyez sur le bouton Prédire. 

Le résultat est incroyable. Cela montre que l'eau n'est pas buvable.

Vous pouvez même accéder à Fastapi Swagger UI en tapant «/ docs» après l'URL pour tester l'API et générer les résultats. 

8. Déployez l'application sur Hugging Face Hub à l'aide de Docker

Le modèle OpenAI O1 a généré le code Docker, un guide et des liens de référence pour nous pour apprendre avec succès à déployer l'application sur la face étreinte.

Lisez le Docker for Data Science: un tutoriel d'introduction pour savoir comment fonctionne Docker. Vous apprendrez à configurer Docker, à utiliser les commandes Docker, à docker les applications d'apprentissage automatique et à suivre les meilleures pratiques à l'échelle de l'industrie.

Tout d'abord, créez un nouvel espace en cliquant sur la photo de profil sur le site Web de Face Hugging, puis en cliquant sur le bouton "nouvel espace". Tapez le nom de l'application, sélectionnez le type SDK (docker), choisissez le type de licence et appuyez sur «Créer un espace».

Source: Face étreint

Toutes les instructions de déploiement de l'application à l'aide de Docker sont fournies sur la page principale.

Source: Classificateur de qualité de l'eau

Ensuite, nous devons cloner le référentiel.

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)

Dans le référentiel, déplacez les dossiers de l'application et du modèle. Créez un dockerfile et tapez la commande suivante. Le modèle O1 nous a fourni le code; Nous n'avons qu'à changer le numéro de port en 7860.

dockerfile:

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

Créez le fichier exigence.txt contenant des informations sur les packages Python. Nous utiliserons ce fichier pour télécharger et installer tous les packages Python requis sur le serveur cloud.

exigences.txt:

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]

C'est à quoi devrait ressembler notre référentiel d'applications:

Notre modèle est un grand fichier (& gt; 10 Mo), nous devons donc utiliser Git LFS pour le suivre. Installez Git LFS et suivez tous les fichiers avec l'extension «.skops».

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)

Mettez en scène toutes les modifications, engagez-vous avec le message et poussez-le vers le serveur distant.

$ python .\src\preprocess_data.py 

Accédez à votre page d'application sur la face des câlins, et vous verrez qu'il construit le conteneur et installe tous les packages nécessaires. 

Source: Classificateur de qualité de l'eau

Après quelques minutes, l'application sera prête à l'emploi. Il ressemble à l'application locale. Essayons de lui fournir les valeurs d'échantillon et générer les résultats. 

Source: Classificateur de qualité de l'eau

Notre application fonctionne parfaitement et a produit les résultats attendus.

Source: Classificateur de qualité de l'eau

Cette application de l'espace facial étreint est disponible pour quiconque peut utiliser, ce qui signifie que nous pouvons y accéder à l'aide de la commande curl dans le terminal. 

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)

Sortie:

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)

Tous les fichiers du projet, les données, les modèles et les métadonnées sont disponibles sur le référentiel Github Kingabzpro / Qualité de l'eau.

Opinion de l'auteur

Le modèle O1-Preview est de loin supérieur à GPT-4O. Il suit parfaitement les instructions et est sans bug, donc le code qu'il génère est prêt à l'emploi. Lors de la création de l'application d'apprentissage automatique, je n'ai eu qu'à apporter des modifications mineures, environ 5%. La meilleure partie est que j'ai également appris de la prise de décision du modèle d'IA, en comprenant pourquoi il a fait certains choix.

Abid Ali Awan

Conclusion

Dans ce tutoriel, nous avons vu à quel point le modèle de raisonnement O1 d'Openai peut être puissant. Nous avons construit un projet complet d'apprentissage automatique avec seulement quelques modifications du code, et cela a fonctionné immédiatement. Le modèle a géré chaque commande parfaitement et a produit d'excellents résultats sans avoir besoin d'instructions de suivi.

En ce moment, nous avons accès aux versions plus petites du modèle O1, comme O1-Preview et O1-Mini. À l'avenir, nous aurons accès au modèle O1 complet, qui sera encore meilleur pour la construction de projets complexes. La clé est de travailler à poser les bonnes questions pour tirer le meilleur parti du modèle.

La construction d'un projet d'apprentissage automatique avec les modèles d'IA est simple, mais si vous voulez en faire une carrière, vous devez comprendre comment ces modèles fonctionnent. Sans cela, il peut être difficile de résoudre des problèmes ou d'appliquer les modèles à des besoins commerciaux spécifiques. Pour obtenir cette compréhension, nous recommandons aux débutants de prendre le spécialiste de l'apprentissage automatique avec Python Career Track. Il comprend 21 cours et 3 projets pour vous apprendre à construire et à améliorer différents types de modèles d'apprentissage automatique.

Gagner une certification AI supérieure

Démontrer que vous pouvez utiliser efficacement et de manière responsable AI.BET CERTIFIÉ, SORTIE

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!