OpenAI O1-Präview-Tutorial: Erstellen eines Projekts für maschinelles Lernen

In diesem Tutorial erstellen wir eine Wasserqualitätsklassifikatoranwendung von Grund auf und stellen sie mit Docker in der Cloud bereit. 

Wir werden zunächst das OpenAI O1 -Modell untersuchen und seine Funktionalität verstehen. Wir werden dann über API und ChatGPT auf das Modell zugreifen, um sowohl mit der O1-Präview- als auch mit O1-Mini-Versionen zu experimentieren, bevor wir effektive Aufforderungen für den Aufbau einer Anwendung zur Wasserqualitätsklassifizierung entwickeln. 

Sobald wir die Ausgabe haben, werden wir den vom O1 -Modell bereitgestellten Code und Dateien in den Projektordner hinzufügen und dann laden, vorbereiten, trainieren und bewerten, indem Python -Code lokal ausgeführt wird. Schließlich erstellen wir eine Fastapi -Anwendung und stellen sie mit Docker auf dem Umarmungsgesicht bereit.

Wenn Sie neu in der KI sind, ist die KI -Fundamentals Skill Track ein großartiger Ausgangspunkt. Es wird Ihnen helfen, über beliebte KI -Themen wie Chatgpt und große Sprachmodelle zu lernen. 

Bild vom Autor

Erste Schritte mit O1-Präview und O1-Mini

Es gibt viele leicht zugängliche O1-Modelle, aber die offiziellen werden entweder über die OpenAI-API oder das ChatGPT Plus- oder Team-Abonnement verwendet. 

In diesem Abschnitt lernen wir, wie wir sie verwenden können, um komplexe Probleme zu lösen.

Zugriff auf das O1 -Modell

Wenn Sie mit der OpenAI-API für den Chat-Fertigstellung vertraut sind, müssen Sie den Modellnamen auf "O1-Preview" festlegen und eine detaillierte Eingabeaufforderung angeben. Es ist so einfach.

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)

Um auf ChatGPT darauf zuzugreifen, müssen Sie auf die Dropdown-Option der Modellauswahl klicken und das unten gezeigte Modell „O1-Preview“ auswählen.

Verwenden Sie das O1-Präview-Modell in Chatgpt

Die Eingabeaufforderungen des O1 -Modells sind unterschiedlich. Sie müssen es mit mehreren Anweisungen oder detaillierten Fragen zur Verfügung stellen, um seine Leistung vollständig zu erkennen. Es kann eine lange und komplexe Anweisung dauern, um eine optimale Antwort zu generieren.

Steuern für ein freiberufliches Geschäft in Europa kann komplex sein. Wir werden das O1 -Modell verwenden, um unsere Steuerpflicht gegenüber der spanischen Regierung zu bestimmen.

Eingabeaufforderung: „ Ich bin ein Freiberufler in Spanien, der für ein in den USA ansässiger Unternehmen arbeitet. Im vergangenen Jahr habe ich 120.000 USD verdient, und ich muss die Höhe der Steuern berechnen, die ich schulde. Bitte berücksichtigen Sie, dass ich vor 8 Monaten nach Spanien gezogen bin. ”

Es dauerte fast 30 Sekunden, um zu antworten, aber die Antwort war detailliert. Es enthielt mathematische Gleichungen, Steuerinformationen und alle erforderlichen Details, um festzustellen, wie viel wir der spanischen Regierung schulden.

Die Antwort wurde in die folgenden Teile unterteilt:

1. Bestimmen Sie Ihren Steueraufenthaltsstatus
2. Konvertieren Sie Ihr Einkommen in Euro
3. Berechnen Sie Ihr steuerpflichtiges Einkommen
4. Berechnung der Beiträge der sozialen Sicherheit
5. Gesamt geschätzte Steuern geschuldet
6. Wichtige Notizen
7. Nächste Schritte

Überprüfung des Zusammenfassungsabschnitts bietet uns die ungefähre Steuer, die der Regierung geschuldet ist, was sehr hilfreich ist. 

Sie können in der Chat-Antwort auf das Dropdown-Menü klicken, um die Denk- und Entscheidungskette anzuzeigen. 

Wir können sehen, dass das Modell den Kontext, steuerlichen Implikationen und Steuerklassen versteht, bevor er auf Ihre Frage antwortet.

Verwenden von O1-Mini-Modell in Chatgpt

Das O1-Mini-Modell ist weniger genau, aber schneller als das O1-Präview-Modell. In unserem Fall werden wir dieses Modell verwenden, um eine statische Website für Data Science -Lebensläufe zu erstellen.

Eingabeaufforderung: „ Bitte erstellen Sie eine statische Website für meinen Datenwissenschafts -Lebenslauf mit einem Python -Framework.“

Es wurde nicht nur eine ordnungsgemäße Lebenslaufwebsite erstellt, sondern auch Anleitung zur Veröffentlichung von Github -Seiten kostenlos.

Die Antwort wurde in die folgenden Teile unterteilt:

1. Einführung in Pelican
2. Voraussetzungen
3. Pelican
einrichten
4. Auswählen eines Themas
5. Erstellen Ihres Lebenslaufinhalts
6. Erstellen des Standorts
7. Automatisieren mit Makefile
8. Bereitstellen Ihrer Lebenslauf -Website
9. Verbesserung Ihrer Lebenslauf -Website
10. Zusätzliche Ressourcen

Es ist eine fantastische Funktion, die Gedankenkette in der Antwort anzuzeigen. Wir können deutlich sehen, dass das Modell über die Verwendung von Pelican, Flask oder Hugo als Web -Framework in Betracht geht. Am Ende hat es die bestmögliche Lösung ausgewählt.

OpenAI O1-Präview-Tutorial: Erstellen einer Wasserqualitätsklassifikatoranwendung

In diesem Projekt werden wir das O1-Präview-Modell verwenden, um eine Wasserqualitätsklassifizierungsanwendung zu erstellen und bereitzustellen. Dies ist ein ziemlich komplexes Projekt, da wir es mit einer detaillierten Beschreibung dessen geben, was wir suchen.

Wenn Sie sich mit ChatGPT ein Datenwissenschaftsprojekt erstellen möchten, lesen Sie einen Leitfaden zur Verwendung von ChatGPT für Datenwissenschaftsprojekte. Sie erfahren, wie Sie ChatGPT für Projektplanung, Datenanalyse, Datenvorverarbeitung, Modellauswahl, Hyperparameter -Tuning, Entwicklung einer Web -App und Bereitstellung verwenden.

1. Eingabeaufforderung in Engineering

Wir werden mehr Zeit mit einem schnellen Engineering verbringen, da wir sicherstellen möchten, dass alle Projektrichtlinien dem Modell zur Verfügung gestellt werden. 

Die Eingabeaufforderung ist in drei Teile unterteilt:

1. Projektbeschreibung: Eine detaillierte Erklärung des Projekts und was wir erstellen möchten.
2. Ziele und Beschränkungen: Geben Sie die Zielinformationen an, z. B. das Ziel, eine Genauigkeit von 90% zu erreichen.  
3. Schritte zu befolgen: Geben Sie alle erforderlichen Schritte an, die es ausführen soll. Zum Beispiel die Aufnahme von Daten mit Kaggle -API, Speichern von Metriken im Ordner, die Durchführung von Datenanalysen, das Training und die Bewertung des Modells und vieles mehr. Schreiben Sie so viele Schritte wie möglich.

Lesen Sie eine Anfängerhandbuch zum Chatgpt -Eingabeaufforderung, um zu erfahren, wie Sie ordnungsgemäße Eingabeaufforderungen in Chatgpt schreiben und die erforderlichen Ergebnisse generieren. Prompt Engineering ist eine Kunst und ist mit der Einführung des O1 -Modells notwendiger geworden, um zu lernen.

Eingabeaufforderung: „Mein Projektmanager hat uns beauftragt, eine Wasserqualitätsanwendung mit dem Kaggle-Datensatz zu entwickeln, das unter https://www.kaggle.com/datasets/adityakadiwal/water-potability verfügbar ist. Bitte geben Sie alle erforderlichen Informationen zu den Dateien, Python -Paketen und Code an, damit wir ein sehr genaues Modell erstellen können.

Ziel ist es, eine Gesamtgenauigkeit von 90% zu erreichen. 

Bitte befolgen Sie die Schritte zum Erstellen des Projekts:

1. Laden Sie den Datensatz von Kaggle mit der API und entpacken Sie es im Datenordner.

2. Vorverarbeitung der Daten vorab und führen Sie einige Datenanalysen durch. Speichern Sie die Analyse -Zahlen und -Dateien im Ordner Metriken.

3. Trainieren Sie das Modell mit dem Scikit-Learn-Framework. Stellen Sie sicher, dass Sie die Experimente verfolgen und die Modelldateien und Metadaten speichern. Speichern Sie das Modell mit der Skops -Bibliothek. 

4. Führen Sie eine detaillierte Modellbewertung durch und speichern Sie die Ergebnisse.

5. Erstellen Sie eine Fastapi -Anwendung, die ein Bild vom Benutzer abnimmt und die Qualität von Wasser vorhersagt.

6. Stellen Sie sicher, dass Sie die Benutzeroberfläche mit Jinja2 -Vorlagen hinzufügen.

7. Stellen Sie die App mit der Option Docker auf dem Umarmungs -Face -Hub ein. ”

Die generierte Antwort hat uns alle Informationen zur Verfügung gestellt, die wir zum Laden der Daten benötigen, das Modell vorarbeiten, trainieren und bewerten, die FastAPI -Anwendung erstellen, eine Benutzeroberfläche erstellen und bereitstellen. 

Das Problem ist, dass es fragmentiert ist und wir möchten, dass es Python- und HTML -Dateien erstellt, damit wir den Code nur kopieren und einfügen können.

Wir werden jetzt den gesamten Code in Python- und HTML -Dateien umwandeln und unser Leben noch einfacher machen.

Follow-up-Eingabeaufforderung: „Bitte konvertieren Sie den Code in die Python-Dateien.“ 

Wie wir sehen, haben wir eine Projektstruktur mit allen Dateien und Code darin. Wir müssen nur Ordner und Dateien erstellen und den Code kopieren und einfügen.

2. Einrichten

Das O1 -Modell enthält alle Informationen, die für die Einrichtung eines Projektverzeichnisses erforderlich sind. Mit dem Code -Editor müssen wir lediglich Ordner und Dateien im Projektverzeichnis erstellen. 

Wir werden die folgenden Ordner erstellen:

1. App: Dieser Ordner enthält die App -Datei für Fastapi- und HTML -Vorlagen.
2. Daten: Dieser Ordner enthält die ursprünglichen Daten und vorverarbeiteten Daten.
3. Metriken: Dieser Ordner enthält Modellbewertungsdaten und Datenanalyse.
4. Modelle: Dieser Ordner enthält gespeicherte Modelle und Scaler -Objekte.
5. src: Dieser Ordner enthält alle Python -Dateien, die uns beim Laden, Verarbeitung, Training und Bewertung helfen.

Zusätzlich enthält das Hauptverzeichnis die Datei DockerFile, Readme und Requires.txt.

3. Laden Sie den Datensatz

Wir laden den Kaggle -Datensatz der Wasserqualität mit der Kaggle -API und entpacken Sie sie in den Datenordner.

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)

Ausführen der Python -Datei lädt den Datensatz herunter, entpackt ihn und entfernen Sie die ZIP -Datei. 

$ 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. Die Daten vorarbeiten und Datenanalyse

durchführen

Die vorverarbeitete Python -Datei lädt die Daten, reinigt sie, verarbeitet fehlende Daten, skaliert sie und speichert dann den Skalier- und vorverarbeiteten Datensatz. Es wird auch die Datenanalyse durchführen und die Metriken und die Datenvisualisierung speichern.

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)

Wir haben vorverarbeitete Daten und alle Datenanalyseberichte mit Abbildungen erhalten. 

5. Modellbildung und Training

Das Trainingsskript lädt die vorverarbeiteten Daten und trainiert einen zufälligen Waldklassifizierer. SKOPE wird dann verwendet, um das Modell zu speichern, das Experiment manuell zu verfolgen und die Modellmetadaten als JSON -Datei zu speichern.

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)

Das Trainingsskript generiert eine Modelldatei und Metadaten, wie unten gezeigt.

6. Modellbewertung

Das Modell zur Bewertung des Modells lädt verarbeitete Daten und das gespeicherte Modell, um einen Klassifizierungsbericht, eine Verwirrungsmatrix, die ROC -Kurve, die AUC und die Gesamtgenauigkeit zu generieren. Alle Metriken und Zahlen werden im Ordner Metriken gespeichert.

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

Die Gesamtgenauigkeit ist nicht so gut. Wir können jedoch das O1 -Modell immer bitten, die Genauigkeit zu verbessern.                                                      

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]

Der Ordner Metriken enthält alle gespeicherten Modellbewertungszahlen und Metriken. Wir können es manuell überprüfen, um die Modellleistung im Detail zu verstehen.

7. Erstellen Sie eine Fastapi -Anwendung

Um eine Benutzeroberfläche für die Fastapi -Anwendung zu erstellen, müssen wir die Index- und Ergebnisseiten erstellen. Dies kann durch das Erstellen eines Vorlagenordners im App -Verzeichnis und zum Hinzufügen von zwei HTML -Dateien erfolgen: eine für die Hauptseite und eine für die Ergebnisseite.

Schauen Sie sich das Fastapi -Tutorial an: Eine Einführung in die Verwendung von Fastapi, um das Fastapi -Framework ausführlich zu erfahren und wie Sie es in Ihrem Projekt implementieren können. 

Wenn Sie mit HTML nicht vertraut sind, mach dir keine Sorgen. Sie müssen nur den Code kopieren und einfügen und dem O1 -Modell vertrauen. 

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)

AppTemplatesResult.html:

$ python .\src\preprocess_data.py 

Die Hauptanwendung Python -Datei hat zwei Python -Funktionen: Zuhause und Vorhersage. Die Funktion "Start" zeigt die Begrüßungsseite mit Eingabefelfen und einer Schaltfläche an. Die Funktion "Vorhersage" transformiert die Benutzereingabe, führt sie durch das Modell aus und zeigt das Ergebnis an, das angibt, ob das Wasser trinkbar ist oder nicht.

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)

wir werden die App zuerst lokal testen, um zu überprüfen, ob sie ausgeführt wird.

$ python .\src\train_model.py 

Durch Ausführen der Python -Datei mit Uvicorn erhalten wir die lokale Adresse, die in unseren Browser kopiert und eingefügt werden kann. 

Hinweis: Alle Informationen zum Ausführen der Dateien werden auch vom O1 -Modell bereitgestellt.

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

Wie wir sehen, funktioniert die App einwandfrei. 

Stellen wir es mit den zufälligen Werten zur Überprüfung der Wasserqualität und drücken Sie die Vorhersage -Taste. 

Das Ergebnis ist erstaunlich. Es zeigt, dass Wasser nicht trinkbar ist.

Sie können sogar auf die UI der Swagger von Fastapi zugreifen, indem Sie nach der URL „/docs“ eingeben, um die API zu testen und die Ergebnisse zu generieren. 

8. Stellen Sie die App mit Docker

auf dem Umarmungs -Face -Hub ein

Das OpenAI O1 -Modell hat den Docker -Code, einen Leitfaden und Referenzlinks generiert, damit wir erfolgreich erfahren können, wie die Anwendung auf dem Umarmungsgesicht bereitgestellt wird.

Lesen Sie den Docker for Data Science: Ein Einführungs -Tutorial, um zu erfahren, wie Docker funktioniert. Sie lernen, wie Sie Docker einrichten, Docker-Befehle verwenden, maschinelles Lernen anwenden und die branchenweiten Best Practices befolgen.

Erstellen Sie zuerst einen neuen Speicherplatz, indem Sie auf das Profilbild auf der Umarmungs -Face -Website klicken und dann auf die Schaltfläche "neuer Speicherplatz" klicken. Geben Sie den App -Namen ein, wählen Sie den SDK -Typ (Docker), wählen Sie den Lizenztyp und drücken Sie "Speicherplatz".

Quelle: umarmtes Gesicht

Alle Anweisungen zur Bereitstellung der App mit Docker finden Sie auf der Hauptseite.

Quelle: Wasserqualitätsklassifizier

Als nächstes müssen wir das Repository klonen.

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)

Verschieben Sie im Repository die App- und Modellordner. Erstellen Sie eine Dockerfile und geben Sie den folgenden Befehl ein. Das O1 -Modell hat uns den Code zur Verfügung gestellt. Wir müssen die Portnummer nur auf 7860 ändern.

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

Erstellen Sie die Datei "Anforderungen.txt" mit Informationen zu den Python -Paketen. Wir werden diese Datei verwenden, um alle erforderlichen Python -Pakete auf dem Cloud -Server herunterzuladen und zu installieren.

Anforderungen.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]

So sollte unser App -Repository aussehen:

Unser Modell ist eine große Datei (& gt; 10 MB), daher müssen wir Git LFS verwenden, um sie zu verfolgen. Installieren Sie Git LFS und verfolgen Sie alle Dateien mit der Erweiterung ".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)

Bilden Sie alle Änderungen auf, begehen Sie sich mit der Nachricht und geben Sie sie auf den Remote -Server.

$ python .\src\preprocess_data.py 

Gehen Sie zu Ihrer App -Seite auf dem Umarmungsgesicht, und Sie werden feststellen, dass er den Container erstellt und alle erforderlichen Pakete installiert. 

Quelle: Wasserqualitätsklassifizier

Nach ein paar Minuten ist die App verwendet. Es ähnelt der lokalen App. Versuchen wir, es mit den Stichprobenwerten bereitzustellen und die Ergebnisse zu generieren. 

Quelle: Wasserqualitätsklassifizier

Unsere App funktioniert perfekt und hat die erwarteten Ergebnisse erzielt.

Quelle: Wasserqualitätsklassifizier

Diese umarmende Gesichtsspace -App steht jedem zur Verfügung, was bedeutet, dass wir mit dem Befehl curl im Terminal darauf zugreifen können. 

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)

Ausgabe:

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)

Alle Projektdateien, Daten, Modelle und Metadaten sind im KingabzPro/Wasserqualitäts-App-Github-Repository verfügbar.

Die Meinung des Autors

Das O1-Preview-Modell ist GPT-4O weit überlegen. Es folgt die Anweisungen perfekt und ist fehlerfrei, sodass der von ihm generierte Code verwendet wird. Beim Erstellen der App für maschinelles Lernen musste ich nur geringfügige Änderungen vornehmen, etwa 5%. Das Beste daran ist, dass ich auch aus der Entscheidungsfindung des KI-Modells gelernt habe und verstanden habe, warum es bestimmte Entscheidungen getroffen hat.

In diesem Tutorial haben wir gesehen, wie mächtig Openais O1 -Argumentationsmodell sein kann. Wir haben ein komplettes maschinelles Lernprojekt mit nur wenigen Änderungen am Code erstellt, und es funktionierte sofort. Das Modell hat jeden Befehl perfekt bearbeitet und großartige Ergebnisse erzielt, ohne Follow -up -Anweisungen zu benötigen.

Im Moment haben wir Zugriff auf die kleineren Versionen des O1-Modells wie O1-Präview und O1-Mini. In Zukunft haben wir Zugriff auf das vollständige O1 -Modell, das für den Aufbau komplexer Projekte noch besser sein wird. Der Schlüssel besteht darin, daran zu arbeiten, die richtigen Fragen zu stellen, um das Beste aus dem Modell herauszuholen.

Es ist einfach, ein maschinelles Lernprojekt mit den KI -Modellen zu erstellen. Wenn Sie es jedoch zur Karriere machen möchten, müssen Sie verstehen, wie diese Modelle funktionieren. Ohne dies kann es schwierig sein, Probleme zu beheben oder die Modelle auf bestimmte Geschäftsanforderungen anzuwenden. Um dieses Verständnis zu erlangen, empfehlen wir Anfängern, den Wissenschaftler für maschinelles Lernen mit Python Career Track zu nehmen. Es enthält 21 Kurse und 3 Projekte, um Ihnen beizubringen, wie Sie verschiedene Arten von maschinellem Lernmodellen erstellen und verbessern können.

Das obige ist der detaillierte Inhalt vonOpenAI O1-Präview-Tutorial: Erstellen eines Projekts für maschinelles Lernen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!