Bagaimana Cara Menerapkan Model Pembelajaran Mesin?

Dalam beberapa tahun terakhir, pembelajaran mesin dan kecerdasan buatan telah mendapatkan popularitas yang signifikan. Hal ini kemungkinan besar disebabkan oleh kemajuan dalam pemrosesan bahasa alami dan sistem pemberi rekomendasi.

Artikel ini memperkenalkan machine learning, aplikasinya, opsi penerapan, dan mendemonstrasikan cara menerapkan model machine learning sederhana ke Back4app Container.

Apa yang dimaksud dengan Pembelajaran Mesin?

Pembelajaran mesin adalah subbidang dari kecerdasan buatan. Pada intinya, pembelajaran mesin memanfaatkan algoritme statistik untuk belajar dari data dan membuat prediksi tentang data baru yang belum pernah dilihat sebelumnya.

Dengan kata lain, ini memberi komputer kemampuan untuk belajar tanpa secara eksplisit diprogram.

Meskipun pembelajaran mesin dan kecerdasan buatan sering digunakan secara bergantian, keduanya tidaklah sama.

Pembelajaran mesin berfokus pada algoritme dan struktur data, sedangkan kecerdasan buatan adalah upaya umum untuk menciptakan mesin yang mampu berpikir seperti manusia.

Teknik pembelajaran mesin yang umum digunakan adalah regresi (memprediksi nilai kontinu, misalnya harga rumah) dan klasifikasi (memprediksi kelas dari sekumpulan kelas yang terbatas, misalnya genre film).

Secara umum, kita dapat membagi machine learning menjadi tiga jenis:

• Pembelajaran yang diawasi – algoritme belajar menggunakan set data berlabel. Setiap contoh dalam kumpulan data berisi label (atau disebut variabel target). Algoritme menggunakan ini untuk memprediksi label untuk contoh yang tidak terlihat. Algoritma pembelajaran terawasi termasuk kNN, decision trees, dll.

• Pembelajaran tanpa pengawasan – algoritme belajar tanpa panduan eksplisit. Terserah pada algoritme untuk menemukan pola dalam data dan membuat prediksi berdasarkan pola tersebut. Contoh algoritme adalah pengelompokan k-means.

• Pembelajaran penguatan – algoritme belajar melalui uji coba dan kesalahan. Algoritme ini biasanya berbasis hadiah, dan tujuan algoritme ini adalah memaksimalkan hadiah. Contoh: algoritma genetika.

Pada bagian praktis dari artikel ini, kita akan membahas proses pembuatan model secara umum. Kita akan menyelesaikan tugas klasifikasi menggunakan pembelajaran terawasi.

Aplikasi Pembelajaran Mesin

Mari kita lihat beberapa aplikasi pembelajaran mesin di dunia nyata!

Sistem Rekomendasi

Sistem pemberi rekomendasi menyarankan item (film, produk, dll.) yang sebaiknya dikonsumsi pengguna. Sistem ini bisa berbasis konten atau berbasis kolaboratif.

Saat ini sistem rekomendasi digunakan oleh hampir semua perusahaan. Sistem ini memungkinkan perusahaan untuk meningkatkan kesuksesan bisnis, menciptakan permintaan tambahan, meningkatkan keterlibatan pengguna, mempelajari pelanggan, dan banyak lagi.

Netflix, misalnya, menggunakannya untuk merekomendasikan film, Spotify untuk merekomendasikan lagu, dan YouTube untuk menyarankan video yang harus Anda tonton berdasarkan minat Anda.

Pemrosesan Bahasa Alami (NLP)

Pemrosesan bahasa alami (NLP) memungkinkan komputer memproses dan memahami bahasa manusia. Pembangkitan bahasa alami (NLG) memungkinkan komputer menghasilkan bahasa manusia.

Teknologi ini digunakan oleh chatbot, alat penerjemah bahasa, alat analisis sentimen, dan banyak lagi. ChatGPT adalah salah satu contoh paling terkenal yang memanfaatkan NLP dan NLG.

Ingin mempelajari lebih lanjut tentang ChatGPT? Lihat artikel kami yang lain berjudul Bagaimana cara membuat aplikasi menggunakan ChatGPT?

Visi Komputer dan Pengenalan Gambar

Visi komputer memberikan komputer kemampuan untuk “melihat” dan “memahami” gambar dan video. Hal ini memungkinkan mereka untuk melakukan segmentasi (real-time), mengenali objek, wajah, dan bahkan emosi.

Ini adalah teknologi yang digunakan oleh aplikasi foto untuk menandai teman Anda secara otomatis. Selain itu, teknologi ini juga digunakan oleh sistem pengawasan untuk mendeteksi perilaku yang mencurigakan.

Deteksi Penipuan

Bisnis menggunakan pembelajaran mesin untuk mendeteksi aktivitas yang mencurigakan dalam transaksi atau perilaku pengguna. Sistem ini dapat mendeteksi tindakan yang berpotensi curang dengan mempelajari tren dan ketidaknormalan, sehingga melindungi bisnis dan pelanggan dari penipuan dan kejahatan dunia maya.

Mobil Tanpa Pengemudi

Mengemudi mobil otonom adalah salah satu masalah pembelajaran mesin yang lebih rumit. Ini menggabungkan berbagai aplikasi seperti visi komputer, deteksi anomali, prediksi perilaku, perencanaan jalur, dan lain-lain.

Pada saat artikel ini ditulis, kita masih jauh dari mobil yang sepenuhnya otonom. Mobil “swakemudi” saat ini hanya bekerja dengan baik di wilayah geografis yang terbatas.

Opsi Penerapan Pembelajaran Mesin

Untuk menerapkan model pembelajaran mesin, Anda biasanya menyajikannya dari aplikasi web. Oleh karena itu, opsi penerapan model pembelajaran mesin hampir sama dengan penerapan aplikasi web. Mari kita lihat mereka!

Di tempat

Penerapan di lokasi memerlukan hosting dan pengelolaan peralatan TI, seperti server dan perangkat penyimpanan, di lokasi perusahaan yang sebenarnya.

Strategi tradisional ini membutuhkan investasi awal yang cukup besar dalam perangkat keras dan perangkat lunak serta pemeliharaan dan dukungan yang berkelanjutan.

Kelebihannya termasuk tingkat kontrol & keamanan yang lebih tinggi dan kustomisasi yang lebih mudah diakses. Di sisi lain, kekurangannya adalah biaya, skalabilitas, dan pemeliharaan.

Awan

Sebaliknya, penerapan cloud menggunakan layanan pihak ketiga untuk meng-host infrastruktur dan aplikasi melalui internet.

Model ini memungkinkan pengguna untuk membayar sesuai kebutuhan untuk sumber daya dan layanan yang dapat diskalakan, yang ditangani oleh penyedia layanan cloud.

Kelebihannya termasuk skalabilitas, kemudahan penggunaan, dan tidak ada biaya di muka. Di sisi lain, kekurangannya adalah tingkat kontrol yang lebih rendah, fleksibilitas yang lebih rendah, dan kemungkinan terkunci oleh vendor.

Contoh platform berbasis Cloud meliputi:

• Back4app
• Amazon Web Services (AWS)
• Google Cloud Platform (GCP)
• Microsoft Azure

Algoritma Pembelajaran Mesin yang Populer

Algoritme pembelajaran mesin yang populer adalah:

• k-Nearest Neighbours (kNN)
• Decision Trees & Random Forests
• Support Vector Machines (SVM)
• Linear Regression
• Naive Bayes
• K-means

Dalam contoh praktis, kita akan menggunakan k-Nearest Neighbours.

Bagaimana cara menerapkan model pembelajaran mesin?

Pada bagian artikel ini, kita akan membangun model pembelajaran mesin, menyajikannya dengan FastAPI, mendokumentasi, dan terakhir men-deploy-nya ke Back4app Container.

Prasyarat

• Pengetahuan dasar tentang pembelajaran mesin
• Pengalaman dengan Python dan FastAPI
• Pemahaman dasar tentang Docker dan teknologi kontainerisasi
• Git dan Docker Desktop terinstal di mesin lokal Anda

Gambaran Umum Proyek

Sebelum mendemonstrasikan cara menggunakan model pembelajaran mesin, kita akan membuat model pembelajaran mesin. Kita akan membuat pengklasifikasi kNN sederhana menggunakan dataset Iris yang populer. Tujuan dari model ini adalah untuk memprediksi apakah sebuah pengamatan adalah “setosa”, “versicolour”, atau “virginica” berdasarkan fitur-fitur yang berbeda.

Kemudian kita akan menyimpan model ke dalam berkas, memuatnya ke FastAPI dan menayangkannya melalui endpoint. Setelah itu, kita akan mendockerisasi aplikasi, mendorongnya ke GitHub, dan men-deploy-nya ke Back4app Containers.

Buat Model

Untuk membuat model, kita akan menggunakan Jupyter Notebooks. Anda dapat menginstal Jupyter di mesin lokal Anda atau menggunakan Google Colab secara gratis.

Pertama-tama, buatlah notebook Jupyter baru.

Setiap blok kode dalam bagian artikel ini mewakili sel Jupyter. Anda dapat membuatnya dari menu atau menggunakan keybind “B” (saat berada dalam mode perintah).

Selain itu, jangan lupa untuk menjalankannya (baik dari menu atau dengan menggunakan “ALT + ENTER”).

Tambahkan impor berikut di sel pertama:

import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

from joblib import dump

Memuat Dataset

Dataset Iris disertakan dalam Scikit-learn secara default. Yang harus Anda lakukan adalah memanggil fungsi load_iris() dan mengubah objek menjadi sebuah frame.

Membuat sel baru:

df = load_iris(as_frame=True)["data"]
df["target"] = load_iris(as_frame=True)["target"]

Ketika Anda memuat dataset Iris, dataset tersebut diurutkan berdasarkan variabel target. Hal ini tidak baik karena model pembelajaran mesin kami mungkin hanya melihat beberapa jenis contoh dalam fase pelatihan. Misalnya, hanya “setosa” dan “versicolour”.

Untuk menghindari masalah ini, kita bisa mengocoknya:

df = df.sample(frac=1, random_state=42)

Atribut random_state digunakan untuk reproduktifitas. Anda dapat menggunakan nomor apa pun yang Anda inginkan.

Jelajahi Dataset

Sebelum membuat model, ada baiknya Anda mengeksplorasi data apa yang Anda hadapi. Untuk melakukan itu, Anda dapat menggunakan fungsi-fungsi bawaan Pandas, seperti head(), describe(), dan sebagainya.

# Displays the first five rows of the dataset
df.head(5)

# Generates descriptive statistics
df.describe()

Selain itu, Anda harus memvisualisasikan dataset untuk mengetahui fitur mana yang paling baik dalam memisahkan contoh-contoh dan algoritme pembelajaran mesin apa yang dapat berguna untuk masalah Anda.

Gambar di atas diambil dari artikel Panduan Visualisasi Data dengan Python. Pastikan Anda membacanya untuk mempelajari lebih lanjut tentang visualisasi data.

Gambar menunjukkan bahwa titik “merah” dapat dipisahkan secara linear dari dua titik lainnya. Sebaliknya, titik “biru” dan “hijau” tidak dapat dipisahkan secara linear.

Pisahkan Dataset

Selanjutnya, mari kita tentukan fitur (prediktor) dan variabel target:

features = [
    "sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"
]
target = "target"

Kemudian mengekstraknya menjadi X (data fitur) dan y (data variabel target) dan test train membaginya:

X = df[features].values
y = df[target].values

dev_X, test_X, dev_y, test_y = train_test_split(X, y, test_size=0.25, random_state=42)

Dengan menggunakan test_size = 0.25, 25% dari dataset digunakan untuk pengujian, sementara 75% digunakan untuk pelatihan.

Bangun Model

Selanjutnya, buat pipeline yang pertama-tama menskalakan data dan kemudian menggunakan pengklasifikasi kNN:

knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("predictor", KNeighborsClassifier()),
])
knn.fit(dev_X, dev_y)

Untuk mengetahui mengapa penskalaan sangat penting, baca artikel ini.

Kemudian gunakan validasi silang 10 kali lipat dan periksa kesalahan validasi:

cross_val_score(knn, dev_X, dev_y, cv=10, scoring="accuracy").mean()

# 0.9363636363636362

Mengevaluasi model pada set pengujian:

accuracy_score(test_y, knn.predict(test_X))

# 0.9736842105263158

Validasi dan akurasi pengujian hampir sama. Hal ini mengindikasikan bahwa model kami tidak kekurangan atau kelebihan.

Simpan Model

Terakhir, latih ulang model dengan menggunakan semua data dan simpan ke file model.pkl:

knn.fit(X, y)
dump(knn, "model.pkl")

Jika Anda menggunakan Google Colab, unduh file model.pk karena kita akan membutuhkannya di langkah berikutnya.

Model Sajian

Seperti yang telah disebutkan sebelumnya, kita akan menggunakan FastAPI untuk melayani model.

Lanjutkan dan buat proyek FastAPI baru dan ganti main.py seperti ini:

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {
        "name": "back4app-deploy-ml-model",
        "description": "A FastAPI app serving an ML model",
        "version": "1.0.0",
    }

Mulai server pengembangan:

$ uvicorn app.main:app --reload

Buka http://localhost:8000/, dan Anda akan mendapatkan respons berikut:

{
    "name": "back4app-deploy-ml-model",
    "description": "A FastAPI app serving an ML model",
    "version": "1.0.0"
}

Model Beban

Selanjutnya, mari memuat model dan mendefinisikan model_classes.

Pertama-tama salin model.pkl dari langkah sebelumnya ke dalam root proyek Anda. Kemudian muat model dan tentukan kelas-kelas tepat di bawah inisialisasi aplikasi FastAPI seperti ini:

# ...

model = load("model.pkl")
model_classes = {
    0: "setosa",
    1: "versicolor",
    2: "virginica",
}

# ...

Kita akan menggunakan model_classes untuk menerjemahkan variabel target dari numerik ke teks.

Model Beban

Kemudian buat titik akhir /predict, yang mengambil fitur-fitur dan menggunakan model yang dimuat untuk membuat prediksi:

# main.py

# ...

class Observation(BaseModel):
    """
    A Pydantic model for the observation data.
    This is our ML model's input data.
    """
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float


@app.post("/predict")
async def predict(observation: Observation):
    predictions = model.predict([[
        observation.sepal_length,
        observation.sepal_width,
        observation.petal_length,
        observation.petal_width,
    ]])
    prediction = predictions[0]
    prediction_class = model_classes[prediction]
    return {
        "prediction": int(prediction),
        "prediction_class": prediction_class,
    }

Titik akhir mengembalikan prediksi numerik serta prediksi pengujian yang mudah digunakan.

Jangan lupa tentang impor di bagian atas file:

from joblib import load
from pydantic import BaseModel

Main.py akhir Anda akan terlihat seperti ini.

Mulai ulang server pengembangan dan arahkan ke http://localhost:8000/docs di browser web favorit Anda. FastAPI secara otomatis menghasilkan dokumentasi interaktif untuk semua titik akhir Anda.

Uji model dengan mengirimkan permintaan seperti ini:

Hebat, aplikasi web kami sekarang sudah berfungsi sepenuhnya!

Aplikasi Dockerize

Pada bagian artikel ini, kita akan mendockerisasi aplikasi web. Kita akan membuat berkas Docker dan mengonfigurasi berkas .dockerignore.

Dockerfile

Dockerfile adalah berkas yang berisi instruksi yang harus diikuti oleh Docker Engine untuk membangun citra.

Hal ini biasanya termasuk mentransfer file, menentukan gambar dasar, mengonfigurasi direktori kerja, menjalankan perintah khusus, dan banyak lagi.

Perintah Dockerfile biasanya ditulis dengan huruf kapital semua dan langsung diikuti dengan argumen yang sesuai.

<COMMAND> <arg1> <arg2> ... <arg_n>

# Example
WORKDIR /app

Kunjungi referensi Dockerfile untuk mengetahui lebih lanjut tentang semua instruksi.

Di root proyek, buatlah sebuah Dockerfile:

# Dockerfile

# Set the base image
FROM python:3.12.2-alpine3.19

# Install the required dependencies (gcc)
RUN apk add build-base

# Set the working directory
WORKDIR /app

# Confingure Python using environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Copy the requirements file into the image and install them
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade pip
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy the source code into the image
COPY . .

# Expose the port
EXPOSE 8000

# Start the Uvicorn server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

.dockerignore

Saat bekerja dengan Docker, Anda akan ingin membuat gambar yang sekecil mungkin.

Salah satu cara untuk mengurangi ukuran gambar adalah dengan memanfaatkan file .dockerignore. File ini bekerja mirip dengan file .gitignore. File ini memungkinkan Anda untuk menghilangkan file yang tidak perlu disertakan dalam gambar.

Di root proyek, buat .dockerignore:

.git/
.idea/

__pycache__/
venv/

create_model.ipynb

Pastikan Anda menyesuaikan file .dockerignore sesuai dengan kebutuhan proyek Anda (misalnya, jika Anda menggunakan IDE yang berbeda).

Bangun, jalankan, uji

Sebelum mendorong gambar ke cloud, sebaiknya Anda mengujinya secara lokal.

Untuk mengikuti panduan ini, Anda perlu menginstal Docker Desktop di mesin Anda.

Buka terminal dan periksa gambar yang sedang diinstal:

$ docker images

Selanjutnya, bangun citra menggunakan Dockerfile:

$ docker build -t iris-webapp:1.0 .

Butuh waktu cukup lama bagi Docker untuk membangun citra. Ini terutama karena Scikit-learn tidak dioptimalkan untuk kontainer Docker. Jangan ragu untuk beristirahat sejenak untuk minum kopi.

Setelah perintah selesai, periksa kembali gambarnya. Gambar yang baru dibuat, seharusnya ada di sana.

Terakhir, gunakan gambar untuk membuat wadah baru:

 $ docker run -p 8000:8000 --name iris-webapp iris-webapp:1.0

Itu dia!

Aplikasi web Anda sekarang sudah terkontainerisasi. Aplikasi ini dapat diakses di http://localhost:8000/ dan bekerja dengan cara yang sama seperti sebelumnya.

Dorong ke GitHub

Pertama, buka GitHub dan buat repositori baru. Catat URL jarak jauhnya karena kita akan membutuhkannya di langkah selanjutnya.

Selanjutnya, kembali ke root proyek Anda.

Sebelum Anda mendorong kode sumber ke cloud, buatlah file .gitignore. File .gitignore memungkinkan Anda menentukan file dan direktori mana yang harus dihilangkan dari kontrol versi.

Jenis file ini beroperasi dengan cara yang sama seperti file .dockerignore.

Di dalam root proyek, buat file .gitignore:

#.dockerignore

.idea/
__pycache__/
venv/

Buka terminal dan jalankan perintah berikut untuk menginisialisasi Git:

$ git init

Tambahkan semua file ke VCS dan komit:

$ git add .
$ git commit -m "first commit"

Terakhir, tambahkan asal GitHub jarak jauh menggunakan URL dari sebelumnya dan dorong kode sumber:

$ git remote add origin <remote_url>
$ git push origin master

Pastikan bahwa URL jarak jauh dari langkah sebelumnya digunakan sebagai pengganti .

Selesai. Jika Anda mengunjungi halaman repositori GitHub sekarang, Anda akan melihat bahwa semua file telah ditambahkan.

Menyebarkan Aplikasi

Untuk menerapkan aplikasi ke Back4app Containers, Anda harus mendaftar atau masuk terlebih dahulu (jika sudah memiliki akun).

Ketika Anda mengautentikasi dengan akun Back4app Anda, Anda akan dibawa ke dasbor aplikasi Anda. Untuk membuat aplikasi baru, klik “Buat aplikasi baru”.

Back4app memungkinkan penerapan Backend sebagai Layanan dan Container sebagai Layanan. Karena kami menerapkan aplikasi dalam kontainer, kami akan menggunakan opsi yang terakhir.

Selanjutnya, Anda harus menghubungkan akun GitHub Anda ke Back4app. Ini akan memungkinkan Back4app menarik kode sumber dari repositori Anda. Anda bisa memberikan akses ke semua repositori atau memilih repositori tertentu.

Setelah repositori diimpor, klik “Pilih”.

Mengkonfigurasi lingkungan tidak diperlukan selain memberikan nama aplikasi yang deskriptif.

Kemudian klik “Buat”.

Back4app akan membutuhkan beberapa menit untuk membangun citra, mendorongnya ke registri kontainer, dan menjalankan kontainer. Setelah penerapan selesai, status aplikasi Anda akan berubah menjadi “Siap”.

Untuk mengunjungi aplikasi Anda, klik URL seperti yang ditunjukkan pada gambar di bawah ini.

Bagus, Anda telah berhasil menerapkan model pembelajaran mesin ke Back4app Containers. Aplikasi web seharusnya bekerja dengan cara yang sama seperti aplikasi lokal. Pastikan untuk menguji aplikasi sekali lagi.

Ringkasan

Dalam artikel ini, Anda telah mempelajari dasar-dasar machine learning, aplikasinya, dan cara menerapkan model machine learning.

Sekarang Anda seharusnya dapat membuat model sederhana Anda sendiri, menyajikannya dengan FastAPI dan menerapkannya ke Back4app Container.

Ambil kode sumber akhir dari repo GitHub back4app-deploy-ml-model.