Tutorial Openai O1-Preview: Membina Projek Pembelajaran Mesin

Dalam tutorial ini, kami akan membuat aplikasi pengelas kualiti air dari awal dan menggunakannya ke awan menggunakan Docker. 

kita akan bermula dengan meneroka model Openai O1 dan memahami fungsinya. Kami kemudian akan mengakses model melalui API dan CHATGPT, bereksperimen dengan kedua-dua versi O1-Preview dan O1-Mini, sebelum membangunkan petunjuk yang berkesan untuk membina aplikasi pengelas kualiti air. 

Sebaik sahaja kami mempunyai output, kami akan menambah kod dan fail yang disediakan oleh model O1 ke dalam folder projek dan kemudian memuatkan, membuat proses, melatih, dan menilai dengan melaksanakan kod python secara tempatan. Akhirnya, kami akan membina aplikasi Fastapi dan menggunakannya pada muka yang memeluk menggunakan Docker.

Jika anda baru ke AI, trek kemahiran AI Fundamentals adalah tempat yang bagus untuk bermula. Ia akan membantu anda mempelajari topik AI yang popular seperti CHATGPT dan model bahasa yang besar. 

imej oleh pengarang

Bermula dengan O1-Preview dan O1-Mini

Terdapat banyak model O1 yang mudah diakses, tetapi yang rasmi sama ada melalui API OpenAI atau menggunakan langganan ChatGPT Plus atau pasukan. 

Di bahagian ini, kita akan belajar bagaimana kita boleh menggunakannya untuk menyelesaikan masalah yang kompleks.

mengakses model O1

Jika anda sudah biasa dengan API Openai untuk penyelesaian sembang, anda perlu menetapkan nama model kepada "O1-Preview" dan memberikan petikan terperinci. Ia adalah mudah. ​​

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)

Untuk mengaksesnya di CHATGPT, anda perlu mengklik pilihan dropdown pemilihan model dan pilih model "O1-Preview", seperti yang ditunjukkan di bawah.

menggunakan model O1-Preview dalam CHATGPT

arahan model O1 adalah berbeza. Anda perlu memberikannya dengan pelbagai arahan atau soalan terperinci untuk merealisasikan kuasa sepenuhnya. Ia boleh mengambil arahan yang panjang dan kompleks untuk menghasilkan jawapan yang optimum.

Mengira cukai untuk perniagaan bebas di Eropah boleh menjadi kompleks. Kami akan menggunakan model O1 untuk menentukan liabiliti cukai kami kepada kerajaan Sepanyol.

prompt: " Saya seorang freelancer di Sepanyol yang bekerja untuk syarikat berasaskan AS. Sepanjang tahun yang lalu, saya telah memperoleh 120,000 USD, dan saya perlu mengira jumlah cukai yang saya berhutang. Sila ambil kira bahawa saya berpindah ke Sepanyol 8 bulan yang lalu.

"

Ia mengambil masa hampir 30 saat untuk bertindak balas, tetapi responsnya terperinci. Ia termasuk persamaan matematik, maklumat cukai, dan semua butiran yang diperlukan untuk menentukan berapa banyak kita berhutang kepada kerajaan Sepanyol.

Tanggapan dibahagikan kepada bahagian -bahagian berikut:

1. Tentukan status kediaman cukai anda
2. menukar pendapatan anda ke euro
3. Kirakan pendapatan boleh dikenakan cukai anda
4. Kirakan Sumbangan Keselamatan Sosial
5. Jumlah Cukai Anggaran Berhutang
6. Nota penting
7. Langkah seterusnya

Mengkaji seksyen Ringkasan memberikan kami jumlah cukai anggaran yang terhutang kepada kerajaan, yang sangat membantu. 

Anda boleh mengklik pada menu lungsur dalam respons sembang untuk melihat rantaian pemikiran dan membuat keputusan. 

kita dapat melihat bahawa model itu memahami konteksnya, implikasi cukai, dan pendakap cukai sebelum menjawab soalan anda.

menggunakan model O1-Mini dalam CHATGPT

Model O1-Mini kurang tepat tetapi lebih cepat daripada model O1-Preview. Dalam kes kami, kami akan menggunakan model ini untuk membuat laman web statik untuk resume sains data.

prompt: " Sila buat laman web statik untuk resume sains data saya menggunakan kerangka Python."

Bukan sahaja ia membuat laman web resume yang betul, tetapi ia juga memberikan kami panduan mengenai cara menerbitkannya di halaman GitHub secara percuma.

Tanggapan dibahagikan kepada bahagian -bahagian berikut:

Pengenalan kepada Pelican

Prasyarat

1. Menyediakan Pelican
2. memilih tema
3. Membuat kandungan resume anda
4. Membina laman web
5. Automasi dengan Makefile
6. Menggunakan laman web resume anda
7. Meningkatkan laman web resume anda
8. Sumber tambahan
Ini adalah ciri yang hebat untuk memaparkan rantai pemikiran dalam respons. Kita dapat melihat dengan jelas bahawa model sedang mempertimbangkan menggunakan Pelican, Flask, atau Hugo sebagai kerangka web. Pada akhirnya, ia telah memilih penyelesaian terbaik.

Tutorial Openai O1-Preview: Membina Aplikasi Pengelas Kualiti Air

Dalam projek ini, kami akan menggunakan model O1-Preview untuk membina dan menggunakan aplikasi klasifikasi kualiti air. Ini adalah projek yang agak kompleks, kerana kami akan memberikan gambaran terperinci tentang apa yang kami cari.

Jika anda berminat untuk membina projek sains data menggunakan CHATGPT, lihat panduan untuk menggunakan CHATGPT untuk projek sains data. Anda akan belajar cara menggunakan CHATGPT untuk perancangan projek, analisis data, pra -proses data, pemilihan model, penalaan hiperparameter, membangunkan aplikasi web, dan menggunakannya.

1. Kejuruteraan Prompt

kami akan menghabiskan lebih banyak masa untuk kejuruteraan segera, kerana kami ingin memastikan bahawa semua arahan projek diberikan kepada model. 

Prompt dibahagikan kepada tiga bahagian:

1. Penerangan Projek: Penjelasan terperinci mengenai projek dan apa yang ingin kita bina.
2. Matlamat dan Sekatan: Menyediakan maklumat matlamat, seperti yang bertujuan untuk mencapai ketepatan 90%.  
3. Langkah -langkah untuk diikuti: Sediakan semua langkah yang diperlukan yang anda mahu ambil. Sebagai contoh, pengambilan data menggunakan API Kaggle, menyimpan metrik dalam folder, melakukan analisis data, latihan dan menilai model, dan banyak lagi. Tulis seberapa banyak langkah yang mungkin.

Baca panduan pemula untuk chatgpt kejuruteraan segera untuk mengetahui cara menulis arahan yang betul dalam chatgpt dan menghasilkan hasil yang diperlukan. Kejuruteraan segera adalah seni, dan dengan pengenalan model O1, telah menjadi lebih perlu untuk belajar.

Prompt: "Pengurus Projek saya telah menugaskan kami untuk membangunkan aplikasi kualiti air menggunakan dataset Kaggle yang terdapat di https://www.kaggle.com/datasets/aditityakadiwal/water-potability. Sila berikan semua maklumat yang diperlukan mengenai fail, pakej python, dan kod supaya kami dapat membina model yang sangat tepat.

Matlamatnya adalah untuk mencapai ketepatan keseluruhan 90%. 

Sila ikuti langkah -langkah untuk membina projek:

1. Muatkan dataset dari kaggle menggunakan API dan unzipnya dalam folder data.

2. PREPROSES DATA DAN MENGIKUT beberapa analisis data. Simpan angka dan fail analisis dalam folder metrik.

3. Melatih model menggunakan rangka kerja SCIKIT-Learn. Pastikan anda menjejaki eksperimen dan menyimpan fail model dan metadata. Simpan model menggunakan perpustakaan SKOPS. 

4. Lakukan penilaian model terperinci dan simpan hasilnya.

5. Buat aplikasi Fastapi yang mengambil imej dari pengguna dan meramalkan kualiti air.

6. Pastikan untuk menambah antara muka pengguna menggunakan templat Jinja2.

7. Menyebarkan aplikasi di Hub Face Hugging menggunakan pilihan Docker. "

Sambutan yang dihasilkan telah memberikan kami semua maklumat yang kami perlukan untuk memuatkan data, memprosesnya, melatih dan menilai model, membuat aplikasi FastAPI, membuat antara muka pengguna, dan menggunakannya. 

Isu adalah bahawa ia berpecah dan kami mahu ia membuat fail python dan html untuk kami hanya menyalin dan menampal kod.

Kami sekarang akan menukar semua kod ke dalam fail python dan html, menjadikan kehidupan kita lebih mudah. ​​

Prompt susulan: "Sila tukar kod ke dalam fail python." 

Seperti yang dapat kita lihat, kita mempunyai struktur projek dengan semua fail dan kod di dalamnya. Apa yang perlu kita lakukan ialah membuat folder dan fail dan menyalin dan menampal kod.

2. Menyediakan

Model O1 menyediakan semua maklumat yang diperlukan untuk menubuhkan direktori projek. Kami hanya perlu membuat folder dan fail dalam direktori projek menggunakan editor kod. 

kami akan membuat folder berikut:

1. App: Folder ini akan mengandungi fail aplikasi untuk templat FastAPI dan HTML.
2. Data: Folder ini akan mengandungi data asal dan data pra -diproses.
3. metrik: folder ini akan mengandungi data penilaian model dan analisis data.
4. Model: Folder ini akan mengandungi model yang disimpan dan objek scaler.
5. src: folder ini akan mengandungi semua fail python yang akan membantu kami memuatkan, memproses, latihan, dan penilaian.

Selain itu, direktori utama akan mengandungi fail dockerfile, readme, dan keperluan.txt.

3. Muatkan dataset

Kami akan memuatkan dataset kualiti kualiti air menggunakan API Kaggle dan unzipnya ke dalam folder data.

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)

Menjalankan fail python akan memuat turun dataset, unzip it, dan keluarkan fail 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. Pra -proses data dan lakukan analisis data

Fail python preprocessing akan memuatkan data, membersihkannya, mengendalikan data yang hilang, skala itu, dan kemudian simpan dataset scaler dan pra -diproses. Ia juga akan melakukan analisis data dan menyimpan metrik dan visualisasi data.

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)

kami mendapat data pra -diproses dan semua laporan analisis data dengan angka. 

5. Bangunan dan Latihan Model

Skrip latihan memuatkan data yang telah diproses dan menggunakannya untuk melatih pengelas hutan rawak. Skope kemudian digunakan untuk menyimpan model, menjejaki eksperimen secara manual, dan simpan metadata model sebagai fail JSON.

Skrip latihan akan menghasilkan fail model dan metadata, seperti yang ditunjukkan di bawah.

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

6. Penilaian Model

Skrip penilaian model memuat data yang diproses dan model yang disimpan untuk menghasilkan laporan klasifikasi, matriks kekeliruan, lengkung ROC, AUC, dan ketepatan keseluruhan. Semua metrik dan angka disimpan dalam folder metrik.

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

Ketepatan keseluruhannya tidak begitu baik. Walau bagaimanapun, kami sentiasa boleh meminta model O1 untuk meningkatkan ketepatan.                                                      

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]

Folder Metrik mengandungi semua angka penilaian model dan metrik yang disimpan. Kita boleh mengkaji secara manual untuk memahami prestasi model secara terperinci.

7. Buat aplikasi fastapi

Untuk membuat antara muka pengguna untuk aplikasi FastAPI, kita perlu membuat halaman indeks dan hasil. Ini boleh dilakukan dengan membuat folder templat dalam direktori aplikasi dan menambah dua fail HTML: satu untuk halaman utama dan satu untuk halaman hasil.

Lihat tutorial FastAPI: Pengenalan menggunakan FastAPI untuk belajar secara terperinci mengenai kerangka FastAPI dan bagaimana anda boleh melaksanakannya dalam projek anda. 

Jika anda tidak biasa dengan HTML, jangan risau. Anda hanya perlu menyalin dan menampal kod dan mempercayai model O1. 

apptemplatesform.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 

Fail python aplikasi utama mempunyai dua fungsi python: rumah dan meramalkan. Fungsi "Rumah" memaparkan halaman Selamat Datang yang mengandungi kotak input dan butang. Fungsi "Ramalan" mengubah input pengguna, menjalankannya melalui model, dan memaparkan hasil yang menunjukkan sama ada air itu boleh diminum atau tidak.

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)

kami akan menguji aplikasi secara tempatan terlebih dahulu untuk mengesahkan sama ada ia berjalan.

$ python .\src\train_model.py 

Dengan menjalankan fail python menggunakan uvicorn, kami memperoleh alamat tempatan yang boleh disalin dan disisipkan ke dalam penyemak imbas kami. 

Nota: Semua maklumat mengenai cara menjalankan fail juga disediakan oleh model 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}%")

Seperti yang dapat kita lihat, aplikasinya berfungsi dengan baik. 

mari kita sediakan dengan nilai rawak untuk memeriksa kualiti air dan tekan butang Predict. 

Hasilnya menakjubkan. Ia menunjukkan bahawa air tidak boleh diminum.

Anda juga boleh mengakses UI Swagger FastAPI dengan menaip "/docs" selepas URL untuk menguji API dan menghasilkan hasilnya. 

8. Menyebarkan aplikasi di Hab Face Hugging menggunakan Docker

Model Openai O1 telah menghasilkan kod docker, panduan, dan pautan rujukan bagi kami untuk berjaya mempelajari cara menggunakan aplikasi pada muka yang memeluk.

Baca Docker for Data Science: Tutorial Pengenalan untuk mengetahui bagaimana Docker berfungsi. Anda akan belajar bagaimana untuk menubuhkan Docker, menggunakan arahan Docker, Dockerize Aplikasi Pembelajaran Mesin, dan mengikuti amalan terbaik seluruh industri.

Pertama, buat ruang baru dengan mengklik pada gambar profil di laman web muka yang memeluk dan kemudian mengklik butang "ruang baru". Taipkan nama aplikasi, pilih jenis SDK (Docker), pilih jenis lesen dan tekan "Buat ruang".

Sumber: Hugging Face

Semua arahan untuk menggunakan aplikasi menggunakan Docker disediakan di halaman utama.

Sumber: Pengelas Kualiti Air

Seterusnya, kita perlu mengklon repositori.

Dalam repositori, gerakkan aplikasi dan folder model. Buat Dockerfile dan taipkan arahan berikut. Model O1 telah memberikan kita kod; Kami hanya perlu menukar nombor port ke 7860.

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)

Dockerfile:

Buat fail keperluan.txt yang mengandungi maklumat mengenai pakej python. Kami akan menggunakan fail ini untuk memuat turun dan memasang semua pakej python yang diperlukan pada pelayan awan.

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

syarat.txt:

ini adalah bagaimana repositori aplikasi kami harus kelihatan:

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]

Model kami adalah fail besar (& gt; 10MB), jadi kami perlu menggunakan LFS Git untuk mengesannya. Pasang LFS git dan menjejaki semua fail dengan lanjutan ".skops".

Tahap semua perubahan, komited dengan mesej, dan tolaknya ke pelayan jauh.

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)

pergi ke halaman aplikasi anda pada muka yang memeluk, dan anda akan melihat bahawa ia sedang membina bekas dan memasang semua pakej yang diperlukan. 

$ python .\src\preprocess_data.py 

Sumber: Pengelas Kualiti Air

Selepas beberapa minit, aplikasi akan bersedia untuk digunakan. Ia kelihatan sama dengan aplikasi tempatan. Mari cuba memberikannya dengan nilai sampel dan menghasilkan hasilnya. 

Sumber: Pengelas Kualiti Air

Aplikasi kami berfungsi dengan sempurna dan telah menghasilkan hasil yang diharapkan.

Sumber: Pengelas Kualiti Air

Aplikasi Space Face yang memeluk ini tersedia untuk sesiapa sahaja yang digunakan, yang bermaksud kita boleh mengaksesnya menggunakan perintah curl di terminal. 

output:

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)

Semua fail projek, data, model, dan metadata boleh didapati di repositori GitHub KingabzPro/Air-Kualiti-App.

Pendapat Pengarang

Model O1-Preview jauh lebih tinggi daripada GPT-4O. Ia mengikuti arahan dengan sempurna dan bebas bug, jadi kod yang dihasilkannya siap digunakan. Apabila membina aplikasi pembelajaran mesin, saya hanya perlu membuat perubahan kecil, kira -kira 5%. Bahagian yang terbaik ialah saya juga belajar dari membuat keputusan model AI, memahami mengapa ia membuat pilihan tertentu.

Dalam tutorial ini, kita telah melihat bagaimana model penalaran Openai Openai yang kuat boleh. Kami membina projek pembelajaran mesin lengkap dengan hanya beberapa perubahan pada kod, dan ia berfungsi dengan segera. Model ini mengendalikan setiap arahan dengan sempurna dan menghasilkan hasil yang hebat tanpa memerlukan arahan susulan.

Sekarang, kami mempunyai akses kepada versi kecil model O1, seperti O1-Preview dan O1-Mini. Pada masa akan datang, kami akan mempunyai akses kepada model O1 penuh, yang akan lebih baik untuk membina projek kompleks. Kuncinya adalah untuk berusaha bertanya soalan yang betul untuk mendapatkan yang terbaik dari model.

Membina projek pembelajaran mesin dengan model AI adalah mudah, tetapi jika anda ingin menjadikannya kerjaya, anda perlu memahami bagaimana model ini berfungsi. Tanpa ini, sukar untuk menyelesaikan masalah atau menggunakan model untuk keperluan perniagaan tertentu. Untuk mendapatkan pemahaman ini, kami mengesyorkan pemula mengambil saintis pembelajaran mesin dengan trek kerjaya Python. Ia merangkumi 21 kursus dan 3 projek untuk mengajar anda bagaimana untuk membina dan meningkatkan pelbagai jenis model pembelajaran mesin.

Atas ialah kandungan terperinci Tutorial Openai O1-Preview: Membina Projek Pembelajaran Mesin. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!