Hướng dẫn OpenAI o1-preview: Xây dựng một Dự án Machine Learning

Bắt đầu với o1-preview và o1-mini

Có nhiều mô hình o1 dễ tiếp cận, nhưng các kênh chính thức là qua OpenAI API hoặc đăng ký ChatGPT Plus hay Team. 

Trong phần này, chúng ta sẽ học cách dùng chúng để giải quyết các bài toán phức tạp.

Truy cập mô hình o1

Nếu bạn quen với OpenAI API cho chat completion, bạn chỉ cần đặt tên mô hình là "o1-preview" và cung cấp một prompt chi tiết. Đơn giản là vậy.

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)

Để truy cập trên ChatGPT, bạn nhấp vào danh sách thả chọn mô hình và chọn mô hình “o1-preview” như hình dưới.

Dùng mô hình o1-preview trong ChatGPT

Prompt cho mô hình o1 có khác biệt. Bạn cần cung cấp nhiều chỉ dẫn hoặc câu hỏi chi tiết để phát huy hết sức mạnh. Nó có thể tiếp nhận một hướng dẫn dài và phức tạp để tạo ra câu trả lời tối ưu.

Tính thuế cho công việc tự do tại châu Âu có thể phức tạp. Chúng ta sẽ dùng mô hình o1 để xác định nghĩa vụ thuế của mình với chính phủ Tây Ban Nha.

Prompt: “Tôi là freelancer tại Tây Ban Nha, làm cho một công ty có trụ sở tại Mỹ. Năm vừa qua, tôi kiếm được 120.000 USD và cần tính số thuế phải nộp. Lưu ý rằng tôi chuyển đến Tây Ban Nha cách đây 8 tháng.”

Mất gần 30 giây để phản hồi, nhưng câu trả lời rất chi tiết. Nó bao gồm các phương trình toán, thông tin thuế và mọi chi tiết cần thiết để xác định số tiền phải nộp cho chính phủ Tây Ban Nha.

Phản hồi được chia thành các phần sau:

1. Xác định tình trạng cư trú thuế của bạn
2. Quy đổi thu nhập sang Euro
3. Tính thu nhập chịu thuế
4. Tính đóng góp an sinh xã hội
5. Tổng thuế ước tính phải nộp
6. Lưu ý quan trọng
7. Các bước tiếp theo

Xem phần tóm tắt cho chúng ta con số thuế phải nộp ước lượng cho chính phủ, khá hữu ích. 

Bạn có thể nhấp vào menu thả xuống trong phản hồi để xem chuỗi lập luận và quá trình ra quyết định. 

Ta thấy mô hình hiểu bối cảnh, hệ quả về thuế và các bậc thuế trước khi trả lời câu hỏi của bạn.

Dùng mô hình o1-mini trong ChatGPT

Mô hình o1-mini kém chính xác hơn nhưng nhanh hơn so với o1-preview. Ở đây, chúng ta sẽ dùng mô hình này để tạo một website tĩnh cho hồ sơ Data Science.

Prompt: “Hãy tạo một website tĩnh cho hồ sơ data science của tôi bằng một framework Python.”

Không chỉ tạo đúng một website hồ sơ, nó còn hướng dẫn cách xuất bản miễn phí trên GitHub Pages.

Phản hồi được chia thành các phần sau:

1. Giới thiệu Pelican
2. Điều kiện tiên quyết
3. Thiết lập Pelican
4. Chọn giao diện
5. Tạo nội dung hồ sơ của bạn
6. Xây dựng trang
7. Tự động hóa với Makefile
8. Triển khai website hồ sơ
9. Nâng cấp website hồ sơ
10. Tài nguyên bổ sung

Tính năng hiển thị chuỗi lập luận trong phản hồi thật tuyệt. Ta có thể thấy rõ mô hình cân nhắc dùng Pelican, Flask hoặc Hugo làm framework web. Cuối cùng, nó đã chọn giải pháp tối ưu.

Hướng dẫn OpenAI o1-preview: Xây dựng Ứng dụng Phân loại Chất lượng Nước

Trong dự án này, chúng ta sẽ dùng mô hình o1-preview để xây dựng và triển khai một ứng dụng phân loại chất lượng nước. Đây là dự án khá phức tạp, vì chúng ta sẽ cung cấp mô tả chi tiết về những gì mình cần.

Nếu bạn quan tâm đến việc xây dựng dự án data science bằng ChatGPT, hãy xem Hướng dẫn Sử dụng ChatGPT cho Dự án Data Science. Bạn sẽ học cách dùng ChatGPT cho lập kế hoạch, phân tích dữ liệu, tiền xử lý dữ liệu, chọn mô hình, tinh chỉnh siêu tham số, phát triển ứng dụng web và triển khai.

1. Kỹ thuật tạo prompt

Chúng ta sẽ dành nhiều thời gian cho kỹ thuật tạo prompt, vì muốn chắc chắn mọi chỉ thị của dự án đều được cung cấp cho mô hình. 

Prompt được chia thành ba phần:

1. Mô tả dự án:  Giải thích chi tiết về dự án và những gì chúng ta muốn xây dựng.
2. Mục tiêu và ràng buộc:  Cung cấp thông tin mục tiêu, như hướng tới đạt 90% độ chính xác.  
3. Các bước thực hiện: Liệt kê tất cả bước cần thiết bạn muốn mô hình thực hiện. Ví dụ, lấy dữ liệu bằng Kaggle API, lưu các chỉ số vào thư mục, thực hiện phân tích dữ liệu, huấn luyện và đánh giá mô hình, v.v. Hãy viết càng nhiều bước càng tốt.

Đọc Hướng dẫn Nhập môn Tạo Prompt cho ChatGPT để học cách viết prompt đúng trong ChatGPT và tạo ra kết quả mong muốn. Kỹ thuật tạo prompt là một nghệ thuật, và với sự ra đời của mô hình o1, việc học nó càng trở nên cần thiết.

Prompt: “Quản lý dự án của tôi giao nhiệm vụ phát triển ứng dụng Chất lượng Nước dùng bộ dữ liệu Kaggle tại https://www.kaggle.com/datasets/adityakadiwal/water-potability. Vui lòng cung cấp mọi thông tin cần thiết về các tệp, gói Python và mã để chúng tôi xây dựng mô hình có độ chính xác cao.

Mục tiêu là đạt 90% độ chính xác tổng thể. 

Vui lòng làm theo các bước để xây dựng dự án:

1. Tải bộ dữ liệu từ Kaggle bằng API và giải nén vào thư mục data.

2. Tiền xử lý dữ liệu và thực hiện một số phân tích dữ liệu. Lưu hình ảnh và tệp phân tích vào thư mục metrics.

3. Huấn luyện mô hình bằng framework scikit-learn. Đảm bảo theo dõi thí nghiệm và lưu tệp mô hình cùng siêu dữ liệu. Lưu mô hình bằng thư viện skops. 

4. Thực hiện đánh giá mô hình chi tiết và lưu kết quả.

5. Tạo ứng dụng FastAPI nhận dữ liệu từ người dùng và dự đoán chất lượng nước.

6. Hãy bổ sung giao diện người dùng bằng template Jinja2.

7. Triển khai ứng dụng lên Hugging Face bằng tùy chọn Docker.”

Phản hồi tạo ra đã cung cấp cho chúng ta mọi thông tin cần để tải dữ liệu, tiền xử lý, huấn luyện và đánh giá mô hình, tạo ứng dụng FastAPI, tạo giao diện người dùng và triển khai. 

Vấn đề là nó bị phân mảnh và chúng ta muốn nó tạo các tệp Python và HTML để chỉ việc sao chép-dán mã.

Giờ chúng ta sẽ chuyển toàn bộ mã thành các tệp Python và HTML để công việc càng thêm dễ dàng.

Prompt tiếp theo: “Vui lòng chuyển mã thành các tệp Python.” 

Như có thể thấy, ta có cấu trúc dự án với toàn bộ tệp và mã. Việc cần làm là tạo thư mục và tệp, rồi sao chép-dán mã.

2. Thiết lập

Mô hình o1 cung cấp mọi thông tin cần để thiết lập thư mục dự án. Chúng ta chỉ cần tạo thư mục và tệp trong thư mục dự án bằng trình soạn thảo mã. 

Chúng ta sẽ tạo các thư mục sau:

1. app: Thư mục này chứa tệp app cho FastAPI và các template HTML.
2. data: Thư mục này chứa dữ liệu gốc và dữ liệu đã tiền xử lý.
3. metrics: Thư mục này chứa dữ liệu đánh giá mô hình và phân tích dữ liệu.
4. models: Thư mục này chứa mô hình đã lưu và các đối tượng scaler.
5. src: Thư mục này chứa toàn bộ tệp Python hỗ trợ tải, xử lý, huấn luyện và đánh giá.

Ngoài ra, thư mục gốc sẽ chứa Dockerfile, README và tệp requirements.txt.

3. Tải bộ dữ liệu

Chúng ta sẽ tải bộ dữ liệu Water Quality từ Kaggle bằng Kaggle API và giải nén vào thư mục 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")

Chạy tệp Python sẽ tải bộ dữ liệu, giải nén và xóa tệp 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. Tiền xử lý dữ liệu và phân tích dữ liệu

Tệp Python tiền xử lý sẽ tải dữ liệu, làm sạch, xử lý thiếu, chuẩn hóa, rồi lưu scaler và bộ dữ liệu đã tiền xử lý. Nó cũng thực hiện phân tích dữ liệu và lưu các chỉ số cùng trực quan hóa.

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 

Chúng ta đã có dữ liệu đã tiền xử lý và toàn bộ báo cáo phân tích dữ liệu kèm hình ảnh. 

5. Xây dựng và huấn luyện mô hình

Tập lệnh huấn luyện tải dữ liệu đã tiền xử lý và dùng để huấn luyện Random Forest Classifier. Skope sau đó được dùng để lưu mô hình, theo dõi thí nghiệm thủ công và lưu siêu dữ liệu mô hình dưới dạng 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 

Tập lệnh huấn luyện sẽ tạo tệp mô hình và siêu dữ liệu như dưới đây.

6. Đánh giá mô hình

Tập lệnh đánh giá mô hình tải dữ liệu đã xử lý và mô hình đã lưu để tạo báo cáo phân loại, ma trận nhầm lẫn, đường ROC, AUC và độ chính xác tổng thể. Toàn bộ chỉ số và hình ảnh được lưu trong thư mục 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  

Độ chính xác tổng thể chưa tốt. Tuy nhiên, ta luôn có thể yêu cầu mô hình o1 cải thiện độ chính xác.                                                      

Overall Accuracy: 65.55%

Thư mục metrics chứa toàn bộ hình ảnh và chỉ số đánh giá mô hình đã lưu. Ta có thể xem thủ công để hiểu chi tiết hiệu năng mô hình.

7. Tạo ứng dụng FastAPI

Để tạo giao diện người dùng cho ứng dụng FastAPI, chúng ta cần tạo trang index và trang kết quả. Thực hiện bằng cách tạo thư mục template trong thư mục app và thêm hai tệp HTML: một cho trang chính và một cho trang kết quả.

Xem Hướng dẫn FastAPI: Giới thiệu về Sử dụng FastAPI để tìm hiểu chi tiết về framework FastAPI và cách triển khai trong dự án của bạn. 

Nếu bạn chưa quen với HTML, đừng lo. Bạn chỉ cần sao chép-dán mã và tin tưởng mô hình 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>

Tệp Python ứng dụng chính có hai hàm: home và predict. Hàm "home" hiển thị trang chào mừng với các ô nhập và nút. Hàm "predict" chuyển đổi dữ liệu người dùng nhập, chạy qua mô hình và hiển thị kết quả cho biết nước có uống được hay không.

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

Trước tiên, chúng ta sẽ kiểm thử ứng dụng cục bộ để xác minh nó đang chạy.

$ uvicorn app.main:app --reload 

Khi chạy tệp Python bằng uvicorn, ta có địa chỉ cục bộ để sao chép và dán vào trình duyệt. 

Lưu ý: Mọi thông tin về cách chạy các tệp cũng do mô hình o1 cung cấp.

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

Như có thể thấy, ứng dụng hoạt động tốt. 

Hãy nhập các giá trị ngẫu nhiên để kiểm tra chất lượng nước và nhấn nút dự đoán. 

Kết quả thật ấn tượng. Nó cho thấy nước không thể uống được.

Bạn thậm chí có thể truy cập FastAPI Swagger UI bằng cách gõ “/docs” sau URL để kiểm thử API và tạo kết quả. 

8. Triển khai ứng dụng trên Hugging Face Hub bằng Docker

Mô hình OpenAI o1 đã tạo mã Docker, hướng dẫn và liên kết tham khảo để chúng ta học cách triển khai ứng dụng trên Hugging Face thành công.

Đọc hướng dẫn Docker cho Data Science: Giới thiệu để tìm hiểu cách Docker hoạt động. Bạn sẽ học cách thiết lập Docker, dùng lệnh Docker, đóng gói ứng dụng machine learning và tuân theo các thực hành tốt trong ngành.

Đầu tiên, tạo một Space mới bằng cách nhấp vào ảnh hồ sơ trên trang Hugging Face rồi nhấn nút "New Space". Nhập tên ứng dụng, chọn loại SDK (Docker), chọn giấy phép và nhấn “Create Space”.

Nguồn: Hugging Face

Mọi hướng dẫn để triển khai ứng dụng bằng Docker được cung cấp trên trang chính.

Nguồn: Water Quality Classifier

Tiếp theo, chúng ta cần nhân bản kho lưu trữ.

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

Trong kho lưu trữ, di chuyển thư mục app và models. Tạo Dockerfile và nhập lệnh sau. Mã do mô hình o1 cung cấp; chúng ta chỉ cần đổi cổng thành 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"]

Tạo tệp requirements.txt chứa thông tin các gói Python. Chúng ta sẽ dùng tệp này để tải và cài đặt mọi gói cần thiết trên máy chủ đám mây.

requirements.txt:

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

Kho ứng dụng của chúng ta sẽ trông như thế này:

Mô hình của chúng ta là tệp lớn (> 10MB), nên cần dùng Git LFS để theo dõi. Cài đặt Git LFS và theo dõi tất cả tệp có đuôi “.skops”.

git lfs install
git lfs track "*.skops" 

Đưa tất cả thay đổi vào vùng chờ, commit với thông điệp và đẩy lên máy chủ từ xa.

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

Truy cập trang ứng dụng của bạn trên Hugging Face, bạn sẽ thấy quá trình dựng container và cài đặt các gói cần thiết. 

Nguồn: Water Quality Classifier

Sau vài phút, ứng dụng sẽ sẵn sàng sử dụng. Trông tương tự ứng dụng cục bộ. Hãy thử nhập các giá trị mẫu và tạo kết quả. 

Nguồn: Water Quality Classifier

Ứng dụng của chúng ta hoạt động hoàn hảo và tạo ra kết quả như kỳ vọng.

Nguồn: Water Quality Classifier

Ứng dụng Hugging Face Space này mở cho mọi người sử dụng, nghĩa là chúng ta có thể truy cập bằng lệnh curl trong terminal. 

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

Đầu ra: 

Not Potable

Toàn bộ tệp dự án, dữ liệu, mô hình và siêu dữ liệu có trên kho GitHub kingabzpro/Water-Quality-App.

Quan điểm của Tác giả

Kết luận

Trong hướng dẫn này, chúng ta đã thấy sức mạnh của mô hình lập luận o1 của OpenAI. Chúng ta đã xây dựng trọn vẹn một dự án machine learning chỉ với vài chỉnh sửa nhỏ trong mã, và nó hoạt động ngay lập tức. Mô hình xử lý hoàn hảo mọi lệnh và tạo ra kết quả tốt mà không cần chỉ dẫn tiếp theo.

Hiện tại, chúng ta có quyền truy cập các phiên bản nhỏ hơn của mô hình o1 như o1-preview và o1-mini. Trong tương lai, chúng ta sẽ được dùng phiên bản đầy đủ của o1, còn tốt hơn nữa cho các dự án phức tạp. Mấu chốt là rèn luyện cách đặt câu hỏi đúng để khai thác tối đa mô hình.

Xây dựng dự án machine learning với các mô hình AI thì đơn giản, nhưng nếu bạn muốn theo đuổi sự nghiệp, bạn cần hiểu cách các mô hình này hoạt động. Nếu không, sẽ khó xử lý sự cố hoặc áp dụng mô hình cho nhu cầu kinh doanh cụ thể. Để có hiểu biết này, chúng tôi khuyến nghị người mới bắt đầu theo học lộ trình nghề nghiệp Machine Learning Scientist with Python. Lộ trình này gồm 21 khóa học và 3 dự án, dạy bạn cách xây dựng và cải thiện các loại mô hình machine learning khác nhau.