Panduan Praktikal untuk Menggunakan Model Pembelajaran Mesin

Sebagai saintis data, anda mungkin tahu cara membina model pembelajaran mesin. Tetapi hanya apabila anda menggunakan model anda mendapat penyelesaian pembelajaran mesin yang berguna. Dan jika anda ingin mengetahui lebih lanjut tentang menggunakan model pembelajaran mesin, panduan ini adalah untuk anda.

Langkah-langkah yang terlibat dalam membina dan menggunakan model ML lazimnya boleh diringkaskan seperti: membina model, mencipta API untuk menyampaikan ramalan model, menyimpan API dan menggunakan awan.

Panduan ini memberi tumpuan kepada perkara berikut:

  • Membina model pembelajaran mesin dengan Scikit-learn
  • Mencipta API REST untuk menyampaikan ramalan daripada model menggunakan FastAPI
  • Mengekalkan API menggunakan Docker

Kami akan membina model regresi mudah pada set data perumahan California untuk meramalkan harga rumah. Pada penghujungnya, anda akan mempunyai aplikasi kontena yang menyediakan ramalan harga rumah berdasarkan ciri input yang dipilih.

Menyediakan Persekitaran Projek

Sebelum anda memulakan, pastikan anda telah memasang yang berikut:

  • Versi terbaru Python (Python 3.11 atau lebih baru sebaiknya)
  • Docker untuk kontena; Dapatkan Docker untuk sistem pengendalian anda

⚙️ Untuk mengikuti dengan selesa, anda perlu memahami asas membina model pembelajaran mesin dan bekerja dengan API.

Bermula

Berikut ialah struktur (disyorkan) untuk direktori projek:

project-dir/
│
├── app/
│   ├── __init__.py       	# Empty file
│   └── main.py           	# FastAPI code for prediction API
│
├── model/
│   └── linear_regression_model.pkl  # Saved trained model (after running model_training.py)
│
├── model_training.py      	# Script to train and save the model
├── requirements.txt       	# Dependencies for the project
└── Dockerfile             	# Docker configuration

Kami memerlukan beberapa perpustakaan Python untuk meneruskan. Mari pasang semuanya seterusnya.

Dalam persekitaran projek anda, cipta dan aktifkan persekitaran maya:

$ python3 -m venv v1
$ source v1/bin/activate

Untuk projek yang akan kami usahakan, kami memerlukan panda dan scikit-belajar untuk membina model pembelajaran mesin. Dan FastAPI dan Uvicorn untuk membina API untuk menyampaikan ramalan model.

Jadi mari pasang pakej yang diperlukan ini menggunakan pip:

$ pip3 install pandas scikit-learn fastapi uvicorn

Anda boleh menemui semua kod untuk tutorial ini di GitHub.

Membina Model Pembelajaran Mesin

Sekarang, kami akan melatih model regresi linear menggunakan set data Perumahan California yang terbina dalam scikit-lear. Model ini akan meramalkan harga rumah berdasarkan ciri yang dipilih. Dalam direktori projek, buat fail bernama model_training.py:

# model_training.py
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import pickle
import os

# Load the dataset
data = fetch_california_housing(as_frame=True)
df = data['data']
target = data['target']

# Select a few features
selected_features = ['MedInc', 'AveRooms', 'AveOccup']
X = df[selected_features]
y = target

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the Linear Regression model
model = LinearRegression()
model.fit(X_train, y_train)

# Create a 'model' folder to save the trained model
os.makedirs('model', exist_ok=True)

# Save the trained model using pickle
with open('model/linear_regression_model.pkl', 'wb') as f:
	pickle.dump(model, f)

print("Model trained and saved successfully.")

Skrip ini memuatkan set data perumahan California, memilih tiga ciri (MedInc, AveRooms, AveOccup), melatih model regresi linear dan menyimpannya dalam folder model/ sebagai linear_regression_model.pkl.

Nota: Untuk memastikan perkara mudah, kami hanya menggunakan subset kecil ciri. Tetapi anda boleh cuba menambah lagi.

Jalankan skrip untuk melatih model dan simpannya:

$ python3 model_training.py

Anda akan mendapat mesej berikut dan sepatutnya dapat mencari fail .pkl dalam direktori model/:

Model trained and saved successfully.

Mencipta Apl FastAPI

Kami kini akan membuat API yang menyediakan ramalan menggunakan FastAPI.

Di dalam folder app/, buat dua fail: __init__.py (kosong) dan main.py. Kami melakukan ini kerana kami ingin menyimpan aplikasi FastAPI menggunakan Docker seterusnya.

Dalam main.py, tulis kod berikut:

# app/main.py
from fastapi import FastAPI
from pydantic import BaseModel
import pickle
import os

# Define the input data schema using Pydantic
class InputData(BaseModel):
    MedInc: float
    AveRooms: float
    AveOccup: float

# Initialize FastAPI app
app = FastAPI(title="House Price Prediction API")

# Load the model during startup
model_path = os.path.join("model", "linear_regression_model.pkl")
with open(model_path, 'rb') as f:
    model = pickle.load(f)

@app.post("/predict")
def predict(data: InputData):
    # Prepare the data for prediction
    input_features = [[data.MedInc, data.AveRooms, data.AveOccup]]
    
    # Make prediction using the loaded model
    prediction = model.predict(input_features)
    
    # Return the prediction result
    return {"predicted_house_price": prediction[0]}

Aplikasi FastAPI ini mendedahkan titik akhir /predict yang mengambil tiga ciri (MedInc, AveRooms, AveOccup). Ia menggunakan model terlatih untuk meramalkan harga rumah, dan mengembalikan harga yang diramalkan.

Mengekalkan Apl dengan Docker

Sekarang mari masukkan aplikasi FastAPI kami. Dalam direktori akar projek, buat Fail Docker dan fail requirements.txt.

Mencipta fail Docker

Mari buat fail Docker:

# Use Python 3.11 as the base image
FROM python:3.11-slim

# Set the working directory inside the container
WORKDIR /code

# Copy the requirements file
COPY ./requirements.txt /code/requirements.txt

# Install the Python dependencies
RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

# Copy the app folder into the container
COPY ./app /code/app

# Copy the model directory (with the saved model file) into the container
COPY ./model /code/model

# Expose port 80 for FastAPI
EXPOSE 80

# Command to run the FastAPI app with Uvicorn
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

Ini mencipta bekas ringan untuk aplikasi FastAPI menggunakan Python 3.11 (versi langsing) sebagai imej asas. Ia menetapkan direktori kerja kepada /code, menyalin fail requirements.txt ke dalam bekas dan memasang kebergantungan Python yang diperlukan tanpa caching.

Fail apl dan model FastAPI kemudiannya disalin ke dalam bekas. Port 80 didedahkan untuk aplikasi dan Uvicorn digunakan untuk menjalankan aplikasi FastAPI. Ini menjadikan API boleh diakses pada port 80. Persediaan ini cekap untuk menggunakan apl FastAPI dalam persekitaran kontena.

Mencipta Fail keperluan.txt

Buat fail requirements.txt yang menyenaraikan semua kebergantungan:

fastapi
uvicorn
scikit-learn
pandas

Membina Imej Docker

Memandangkan kita telah menyediakan Dockerfile, requirements.txt dan apl FastAPI, mari bina imej Docker dan jalankan bekas itu.

Bina imej Docker dengan menjalankan arahan binaan docker berikut:

$ docker build -t house-price-prediction-api .

Seterusnya jalankan bekas Docker:

$ docker run -d -p 80:80 house-price-prediction-api

API anda kini sepatutnya berjalan dan boleh diakses di http://127.0.0.1:80.

Anda boleh menggunakan curl atau Postman untuk menguji titik akhir /predict dengan menghantar permintaan POST. Berikut adalah contoh permintaan:

curl -X 'POST' \
  'http://127.0.0.1:80/predict' \
  -H 'Content-Type: application/json' \
  -d '{
  "MedInc": 3.5,
  "AveRooms": 5.0,
  "AveOccup": 2.0
}'

Ini sepatutnya mengembalikan respons dengan harga rumah yang diramalkan, seperti ini:

{
  "predicted_house_price": 2.3248705765077062
}

Menandai dan Menolak Imej Docker ke Hab Docker

Selepas membina imej Docker, jalankan bekas dan mengujinya. Anda kini boleh menolaknya ke Docker Hub untuk perkongsian dan penggunaan yang lebih mudah ke platform awan.

Mula-mula, log masuk ke Docker Hub:

$ docker login

Anda akan digesa untuk memasukkan bukti kelayakan.

Tandai imej Docker:

$ docker tag house-price-prediction-api your_username/house-price-prediction-api:v1

Gantikan your_username dengan nama pengguna Docker Hub anda.

Nota: Ia juga masuk akal untuk menambah versi pada fail model anda. Apabila anda mengemas kini model, anda boleh membina semula imej dengan teg baharu dan menolak imej yang dikemas kini ke Docker Hub.

Tolak imej ke Docker Hub:

$ docker push your_username/house-price-prediction-api:v1

Pembangun lain kini boleh menarik dan menjalankan imej seperti itu:

$ docker pull your_username/house-price-prediction-api:v1
$ docker run -d -p 80:80 your_username/house-price-prediction-api:v1

Sesiapa sahaja yang mempunyai akses kepada repositori Docker Hub anda kini boleh menarik imej dan menjalankan bekas.

Penggulungan dan Langkah Seterusnya

Berikut ialah semakan pantas tentang perkara yang kami lakukan dalam tutorial ini:

  • Latih model pembelajaran mesin menggunakan scikit-learn
  • Bina aplikasi FastAPI untuk menyampaikan ramalan
  • Simpan aplikasi dengan Docker

Kami juga melihat untuk menolak imej Docker ke Docker Hub untuk pengedaran yang lebih mudah. Langkah logik seterusnya ialah menggunakan aplikasi kontena ini ke awan.

Dan untuk ini, anda boleh menggunakan perkhidmatan seperti AWS ECS, GCP atau Azure untuk menggunakan API dalam persekitaran pengeluaran. Beritahu kami jika anda mahukan tutorial tentang menggunakan model pembelajaran mesin ke awan.

Selamat menjalankan tugas!

Rujukan dan Bacaan Lanjutan

  • Tutorial FastAPI: Bina API dengan Python dalam Minit
  • Simpan Aplikasi Python dengan Docker dalam 5 Langkah Mudah
  • FastAPI dalam Bekas