Skip to main content

Membangun Machine Learning hingga Deploy Menggunakan Streamlit dan GitHub

· 60 min read
Ucup TopekoX
Ucup TopekoX
TimposuLabs creator

Machine learning tidak berhenti ketika model berhasil dilatih. Dalam proyek nyata, model perlu dikemas menjadi sebuah aplikasi agar dapat digunakan oleh pengguna.

Pada tutorial ini kita akan membangun proyek machine learning klasifikasi kualitas jeruk mulai dari membaca dataset, memahami data, melakukan exploratory data analysis (EDA), preprocessing, training model, evaluasi, menyimpan model, membuat aplikasi menggunakan Streamlit, hingga melakukan deployment melalui GitHub.

Proyek ini menggunakan dataset jeruk_balance_500.csv dengan 500 data dan 8 kolom. Model yang digunakan adalah Logistic Regression yang dikombinasikan dengan StandardScaler, OneHotEncoder, OrdinalEncoder, ColumnTransformer, dan Pipeline.

tip

Sumber Dataset: https://github.com/adiscreate/belajar_klasifikasi_jeruk

Alur keseluruhan proyek:

Dataset
   ↓
Load Data
   ↓
Data Understanding
   ↓
Exploratory Data Analysis
   ↓
Preprocessing
   ↓
Train-Test Split
   ↓
Model Training
   ↓
Evaluation
   ↓
Prediction
   ↓
Save Model
   ↓
Streamlit Application
   ↓
GitHub
   ↓
Streamlit Community Cloud
   ↓
Aplikasi Online

1. Gambaran Proyek​

Kita akan membuat sistem yang dapat memprediksi kualitas jeruk berdasarkan beberapa karakteristik.

Input yang digunakan:

  • Diameter
  • Berat
  • Tebal kulit
  • Kadar gula
  • Asal daerah
  • Warna
  • Musim panen

Output model:

  • Bagus
  • Sedang
  • Jelek

Secara sederhana:

Karakteristik Jeruk
        ↓
   Machine Learning
        ↓
   Logistic Regression
        ↓
Prediksi Kualitas Jeruk
        ↓
Bagus / Sedang / Jelek

Model kemudian disimpan ke dalam file:

model_klasifikasi_jeruk.joblib

File tersebut akan digunakan oleh aplikasi Streamlit sehingga aplikasi tidak perlu melatih model kembali setiap kali dijalankan.

2. Struktur Project​

Sebelum mulai, buat struktur project seperti berikut:

klasifikasi-jeruk/
│
├── data/
│   └── jeruk_balance_500.csv
│
├── notebook/
│   └── klasifikasi_jeruk.ipynb
│
├── model_klasifikasi_jeruk.joblib
│
├── app.py
│
├── requirements.txt
│
└── README.md

Untuk deployment sederhana, sebenarnya struktur dapat dibuat lebih sederhana:

klasifikasi-jeruk/
│
├── app.py
├── model_klasifikasi_jeruk.joblib
├── requirements.txt
├── README.md
└── jeruk_balance_500.csv

Dataset tidak harus disertakan apabila aplikasi hanya membutuhkan model hasil training.

3. Menyiapkan Environment Python​

Sebaiknya project machine learning menggunakan environment tersendiri agar dependency antarproject tidak saling bertabrakan.

Contoh menggunakan Conda:

conda create -n ml-jeruk python=3.12

Aktifkan environment:

conda activate ml-jeruk

Kemudian install library:

pip install pandas matplotlib scikit-learn joblib streamlit

Library yang digunakan:

LibraryKegunaan
PandasMembaca dan mengolah dataset
MatplotlibMembuat visualisasi
Scikit-learnPreprocessing, training dan evaluasi
JoblibMenyimpan model
StreamlitMembuat aplikasi web
PythonBahasa pemrograman

4. Memuat Dataset​

Dataset yang digunakan bernama:

jeruk_balance_500.csv

Notebook memuat dataset menggunakan Pandas:

import pandas as pd

df = pd.read_csv("jeruk_balance_500.csv")

df

Dataset berisi:

500 rows × 8 columns

Kolom yang tersedia:

diameter
berat
tebal_kulit
kadar_gula
asal_daerah
warna
musim_panen
kualitas

Hal ini sesuai dengan hasil notebook ketika dataset pertama kali dimuat.

5. Memahami Struktur Dataset​

Melihat ukuran dataset​

Gunakan:

df.shape

Output:

(500, 8)

Artinya terdapat:

  • 500 baris
  • 8 kolom

Notebook menghasilkan ukuran dataset (500, 8).

Melihat nama kolom​

df.columns

Output:

Index([
    'diameter',
    'berat',
    'tebal_kulit',
    'kadar_gula',
    'asal_daerah',
    'warna',
    'musim_panen',
    'kualitas'
])

Melihat informasi dataset​

df.info()

Hasil notebook menunjukkan bahwa seluruh 500 baris memiliki nilai pada seluruh kolom.

Empat kolom numerik memiliki tipe float64, sedangkan empat kolom lainnya berupa data string.

6. Memahami Feature dan Target​

Dalam supervised learning terdapat dua bagian utama:

Feature
   ↓
Input untuk model

Target
   ↓
Jawaban yang ingin diprediksi

Pada proyek ini:

Feature​

X = df[
    [
        'diameter',
        'berat',
        'tebal_kulit',
        'kadar_gula',
        'asal_daerah',
        'warna',
        'musim_panen'
    ]
]

Target​

y = df['kualitas']

Dengan demikian:

X
├── diameter
├── berat
├── tebal_kulit
├── kadar_gula
├── asal_daerah
├── warna
└── musim_panen

y
└── kualitas

Notebook menggunakan tujuh feature tersebut untuk memprediksi kolom kualitas.

7. Exploratory Data Analysis​

EDA dilakukan sebelum training untuk memahami pola data.

Beberapa informasi statistik numerik dari dataset:

FeatureMeanMinimumMaximum
Diameter6.5147803.998.73
Berat150.67060074.4277.1
Tebal Kulit0.7304600.271.62
Kadar Gula10.0202005.814.6

Nilai tersebut berasal dari df.describe() pada notebook.

EDA membantu menjawab pertanyaan seperti:

  • Bagaimana hubungan ukuran jeruk dengan beratnya?
  • Apakah kadar gula berkaitan dengan ketebalan kulit?
  • Apakah data dari kelas Bagus, Sedang, dan Jelek memiliki pola tertentu?
  • Apakah terdapat pemisahan pola antar kelas?

Dalam notebook, dua visualisasi utama digunakan untuk melihat hubungan antarfeature tersebut.

8. Visualisasi 1 - Diameter vs Berat​

Visualisasi pertama menggunakan scatter plot untuk melihat hubungan antara diameter dan berat jeruk.

Notebook membagi data berdasarkan kualitas:

bagus = df[df["kualitas"] == "Bagus"]
sedang = df[df["kualitas"] == "Sedang"]
jelek = df[df["kualitas"] == "Jelek"]

Kemudian dibuat scatter plot:

import matplotlib.pyplot as plt

plt.style.use('default')

bagus = df[df["kualitas"] == "Bagus"]
sedang = df[df["kualitas"] == "Sedang"]
jelek = df[df["kualitas"] == "Jelek"]

plt.figure(figsize=(6, 5))

plt.scatter(
    bagus["diameter"],
    bagus["berat"],
    s=100,
    alpha=0.7,
    color="green",
    label="Bagus"
)

plt.scatter(
    sedang["diameter"],
    sedang["berat"],
    s=100,
    alpha=0.7,
    color="orange",
    label="Sedang"
)

plt.scatter(
    jelek["diameter"],
    jelek["berat"],
    s=100,
    alpha=0.7,
    color="red",
    label="Jelek"
)

plt.xlabel("Diameter")
plt.ylabel("Berat")
plt.title("Diameter vs Berat")
plt.legend()

plt.grid(True, linestyle="--", alpha=0.3)

plt.show()

Kode tersebut merupakan visualisasi yang digunakan di notebook.

visualisasi

Tujuan visualisasi​

Scatter plot digunakan untuk melihat apakah terdapat hubungan antara:

Diameter
   ↕
Berat

sekaligus melihat penyebaran masing-masing kelas kualitas.

Apa yang diamati?​

Perhatikan:

  • posisi titik pada sumbu X;
  • posisi titik pada sumbu Y;
  • kepadatan titik;
  • apakah kelas Bagus, Sedang, dan Jelek membentuk pola berbeda;
  • apakah terdapat titik yang jauh dari kelompok lainnya.

Interpretasi​

Jika kelompok kelas terlihat memiliki pola yang cukup berbeda, feature tersebut berpotensi membantu model melakukan klasifikasi.

Namun, visualisasi tidak cukup untuk membuktikan bahwa diameter dan berat merupakan penyebab kualitas jeruk. Visualisasi hanya menunjukkan pola pada dataset.

9. Visualisasi 2 - Tebal Kulit vs Kadar Gula​

Visualisasi kedua melihat hubungan:

Tebal Kulit
     ↕
Kadar Gula

Notebook menggunakan kode:

import matplotlib.pyplot as plt

bagus = df[df["kualitas"] == "Bagus"]
sedang = df[df["kualitas"] == "Sedang"]
jelek = df[df["kualitas"] == "Jelek"]

plt.figure(figsize=(6, 5))

plt.scatter(
    bagus["tebal_kulit"],
    bagus["kadar_gula"],
    s=100,
    alpha=0.7,
    color="green",
    label="Bagus"
)

plt.scatter(
    sedang["tebal_kulit"],
    sedang["kadar_gula"],
    s=100,
    alpha=0.7,
    color="orange",
    label="Sedang"
)

plt.scatter(
    jelek["tebal_kulit"],
    jelek["kadar_gula"],
    s=100,
    alpha=0.7,
    color="red",
    label="Jelek"
)

plt.xlabel("Tebal Kulit")
plt.ylabel("Kadar Gula")
plt.title("Tebal Kulit vs Kadar Gula")
plt.legend()

plt.grid(True, linestyle="--", alpha=0.3)

plt.show()

Visualisasi ini juga merupakan bagian dari notebook asli.

Visualisasi

Tujuan visualisasi​

Visualisasi digunakan untuk melihat apakah terdapat pola hubungan antara:

  • ketebalan kulit;
  • kadar gula;
  • kualitas jeruk.

Interpretasi​

Jika titik-titik berdasarkan kelas kualitas membentuk kelompok atau pola tertentu, informasi tersebut dapat membantu memahami mengapa model dapat melakukan klasifikasi.

Namun sekali lagi, scatter plot hanya menunjukkan pola data, bukan hubungan sebab-akibat.

10. Mengapa Visualisasi Penting?​

Visualisasi bukan sekadar membuat notebook terlihat menarik.

Dalam machine learning, visualisasi membantu kita memahami:

Data
 ↓
Pola
 ↓
Hubungan Feature
 ↓
Kemungkinan Informasi yang Berguna
 ↓
Model

Misalnya jika feature tertentu tidak menunjukkan variasi yang berarti antar kelas, feature tersebut mungkin kurang informatif.

Sebaliknya, apabila terdapat pola yang cukup jelas, feature tersebut berpotensi memberikan informasi yang berguna untuk model.

11. Membagi Data Training dan Testing​

Setelah memahami data, dataset dibagi menjadi:

80% Training
20% Testing

Notebook menggunakan:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

Parameter:

test_size=0.2

berarti 20% data digunakan sebagai data testing.

Sedangkan:

random_state=42

digunakan agar pembagian data dapat direproduksi.

12. Memisahkan Feature Berdasarkan Jenis Data​

Tidak semua feature dapat diproses dengan cara yang sama.

Notebook membagi feature menjadi tiga kelompok.

Feature numerik​

numerical_collumns = [
    'diameter',
    'berat',
    'tebal_kulit',
    'kadar_gula'
]

Feature kategorikal​

categorical_collumns = [
    'asal_daerah',
    'musim_panen'
]

Feature ordinal​

ordinal_collumns = [
    'warna'
]

Notebook menggunakan warna sebagai data ordinal dan menetapkan urutan:

warna_order = [
    'hijau',
    'kuning',
    'oranye'
]

Urutan tersebut kemudian digunakan oleh OrdinalEncoder.

13. StandardScaler​

Feature numerik memiliki skala yang berbeda.

Contohnya:

diameter      → sekitar 4–9
berat         → sekitar 74–277
tebal_kulit   → sekitar 0.27–1.62
kadar_gula    → sekitar 5.8–14.6

Perbedaan skala tersebut dapat memengaruhi algoritma tertentu.

Karena itu notebook menggunakan:

StandardScaler()

untuk feature numerik.

Secara sederhana standardisasi mengubah data sehingga memiliki skala berdasarkan:

z = (x - mean) / standard deviation

14. OneHotEncoder​

Feature:

asal_daerah
musim_panen

merupakan data kategorikal.

Contohnya:

asal_daerah:
- Kalimantan
- Jawa Barat
- Jawa Tengah

Machine learning membutuhkan representasi numerik sehingga kategori tersebut diproses menggunakan:

OneHotEncoder()

Konsep sederhananya:

Kalimantan
Jawa Barat
Jawa Tengah

diubah menjadi representasi numerik berbasis kolom indikator.

15. OrdinalEncoder​

Berbeda dengan kategori biasa, warna memiliki urutan yang ditentukan dalam notebook:

hijau
  ↓
kuning
  ↓
oranye

Notebook menggunakan:

OrdinalEncoder(
    categories=[[
        'hijau',
        'kuning',
        'oranye'
    ]]
)

Tujuannya adalah mempertahankan informasi urutan yang telah ditentukan.

16. ColumnTransformer​

Ketiga preprocessing tersebut kemudian digabungkan menggunakan ColumnTransformer:

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import (
    StandardScaler,
    OneHotEncoder,
    OrdinalEncoder
)

warna_order = ['hijau', 'kuning', 'oranye']

ordinal_order = [warna_order]

preprocessor = ColumnTransformer(
    transformers=[
        (
            "scaller",
            StandardScaler(),
            numerical_collumns
        ),
        (
            "onehot",
            OneHotEncoder(),
            categorical_collumns
        ),
        (
            "ordinal",
            OrdinalEncoder(
                categories=ordinal_order
            ),
            ordinal_collumns
        )
    ]
)

Dengan pendekatan tersebut, preprocessing dapat dilakukan secara terstruktur berdasarkan tipe feature.

17. Pipeline Machine Learning​

Notebook kemudian menggabungkan preprocessing dengan algoritma machine learning menggunakan Pipeline.

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression

model = Pipeline(
    steps=[
        (
            "preprocessor",
            preprocessor
        ),
        (
            "classifier",
            LogisticRegression()
        )
    ]
)

Strukturnya:

Data
 ↓
Preprocessor
 ├── StandardScaler
 ├── OneHotEncoder
 └── OrdinalEncoder
 ↓
Logistic Regression
 ↓
Prediction

Pipeline sangat berguna karena preprocessing dan model menjadi satu kesatuan.

18. Mengapa Pipeline Penting?​

Bayangkan preprocessing dilakukan secara manual.

Saat training:

Training Data
 ↓
Scaling
 ↓
Encoding
 ↓
Model

Kemudian ketika melakukan prediction:

Data Baru
 ↓
Scaling
 ↓
Encoding
 ↓
Model

Proses preprocessing harus konsisten.

Dengan Pipeline, proses tersebut dapat dikemas menjadi satu object model:

Input Data
    ↓
Pipeline
    ├── Preprocessing
    └── Model
    ↓
Prediction

Inilah salah satu alasan mengapa model yang disimpan dari notebook dapat langsung digunakan oleh aplikasi Streamlit.

19. Training Model​

Model dilatih menggunakan data training:

model.fit(X_train, y_train)

Pada tahap ini model mempelajari hubungan antara:

Feature
   ↓
Kualitas

Model menggunakan:

diameter
berat
tebal_kulit
kadar_gula
asal_daerah
warna
musim_panen

untuk mempelajari target:

Bagus
Sedang
Jelek

20. Membuat Prediksi Data Testing​

Setelah training:

y_pred = model.predict(X_test)

Variabel:

y_test

berisi label sebenarnya.

Sedangkan:

y_pred

berisi hasil prediksi model.

Keduanya kemudian dibandingkan untuk mengevaluasi performa model.

21. Evaluasi Model​

Notebook menggunakan:

from sklearn.metrics import (
    accuracy_score,
    classification_report,
    confusion_matrix
)

Kemudian:

print(
    "Akurasi Model: ",
    accuracy_score(y_test, y_pred)
)

print(
    "\nClassification Report:\n",
    classification_report(y_test, y_pred)
)

print(
    "\nConfusion Matrix:\n",
    confusion_matrix(y_test, y_pred)
)

Hasil eksperimen pada notebook:

Akurasi Model: 0.99

Classification report:

              precision    recall    f1-score    support

Bagus           1.00       1.00       1.00          35
Jelek           1.00       0.98       0.99          41
Sedang          0.96       1.00       0.98          24

accuracy                              0.99         100
macro avg       0.99       0.99       0.99         100
weighted avg    0.99       0.99       0.99         100

Hasil tersebut merupakan hasil eksperimen yang tersimpan pada notebook, bukan angka ilustrasi.

22. Memahami Accuracy​

Accuracy menunjukkan proporsi prediksi yang benar dari seluruh data testing.

Pada eksperimen:

Accuracy = 0.99

atau:

99%

Data testing berjumlah 100 data.

Secara sederhana:

100 data testing
       ↓
99 prediksi benar
       ↓
1 prediksi salah

Namun accuracy saja tidak selalu cukup untuk menilai model.

Karena itu digunakan pula:

  • precision;
  • recall;
  • F1-score;
  • confusion matrix.

23. Memahami Precision​

Precision menjawab pertanyaan:

Dari seluruh data yang diprediksi sebagai suatu kelas, berapa banyak yang benar-benar termasuk kelas tersebut?

Pada hasil eksperimen:

Bagus  → 1.00
Jelek  → 1.00
Sedang → 0.96

Precision kelas Sedang lebih rendah dibandingkan dua kelas lainnya.

24. Memahami Recall​

Recall menjawab:

Dari seluruh data yang sebenarnya termasuk suatu kelas, berapa banyak yang berhasil ditemukan model?

Hasil:

Bagus  → 1.00
Jelek  → 0.98
Sedang → 1.00

Recall kelas Jelek sedikit lebih rendah karena terdapat satu data Jelek yang diprediksi sebagai kelas lain.

25. Memahami F1-Score​

F1-score merupakan ukuran yang menggabungkan precision dan recall.

Hasil eksperimen:

Bagus  → 1.00
Jelek  → 0.99
Sedang → 0.98

Nilai tersebut menunjukkan performa model pada ketiga kelas cukup tinggi pada data testing yang digunakan.

26. Confusion Matrix​

Confusion matrix dari notebook:

[[35  0  0]
 [ 0 40  1]
 [ 0  0 24]]

Secara konseptual:

AktualPrediksi BagusPrediksi JelekPrediksi Sedang
Bagus3500
Jelek0401
Sedang0024

Confusion matrix menunjukkan bahwa terdapat satu kesalahan klasifikasi pada kelas Jelek, sementara data lainnya pada testing diklasifikasikan sesuai label aktual.

27. Membuat Prediksi Data Baru​

Setelah model selesai dibuat, kita dapat menggunakannya untuk memprediksi data baru.

Contoh data:

data_baru = pd.DataFrame(
    [[
        7.5,
        150,
        0.5,
        12,
        "Jawa Tengah",
        "hijau",
        "hujan"
    ]],
    columns=[
        'diameter',
        'berat',
        'tebal_kulit',
        'kadar_gula',
        'asal_daerah',
        'warna',
        'musim_panen'
    ]
)

Kemudian:

prediksi = model.predict(data_baru)[0]

prediksi_proba = model.predict_proba(
    data_baru
)[0]

presentase = max(prediksi_proba)

print(
    f"Hasil prediksi {prediksi} "
    f"dengan tingkat keyakinan "
    f"{presentase * 100:.2f}%"
)

Notebook menghasilkan:

Hasil prediksi Sedang dengan tingkat keyakinan 83.21%

28. Memahami Probabilitas Prediksi​

predict_proba() menghasilkan probabilitas untuk masing-masing kelas.

Contohnya secara konsep:

Bagus  → probabilitas tertentu
Jelek  → probabilitas tertentu
Sedang → probabilitas tertentu

Kemudian notebook mengambil probabilitas terbesar:

presentase = max(prediksi_proba)

Perlu diperhatikan bahwa nilai tersebut lebih tepat disebut probabilitas/keyakinan model, bukan jaminan bahwa prediksi benar.

29. Menyimpan Model​

Setelah model selesai dilatih, model tidak perlu dilatih kembali ketika aplikasi digunakan.

Model disimpan menggunakan Joblib:

import joblib

joblib.dump(
    model,
    "model_klasifikasi_jeruk.joblib"
)

Notebook menghasilkan:

['model_klasifikasi_jeruk.joblib']

File tersebut sangat penting karena akan digunakan oleh Streamlit.

30. Mengapa Model Disimpan?​

Tanpa menyimpan model, aplikasi harus melakukan:

Load Dataset
 ↓
Preprocessing
 ↓
Training
 ↓
Model
 ↓
Prediction

setiap kali aplikasi dijalankan.

Hal tersebut tidak ideal.

Dengan model yang sudah disimpan:

model_klasifikasi_jeruk.joblib
              ↓
        Load Model
              ↓
       Data Pengguna
              ↓
         Prediction

Training dilakukan satu kali pada tahap development.

Inference dilakukan ketika aplikasi digunakan.

tip

Link File Jupyter Notebook: https://gitlab.com/topekox/belajar-machine-learning/-/blob/main/data-jeruk-sampai-deploy/belajar-machine-learning-1-data-jeruk.ipynb

31. Membuat Aplikasi Streamlit​

Sekarang kita membuat file:

app.py

Aplikasi akan:

  1. Memuat model.
  2. Menampilkan input pengguna.
  3. Membentuk DataFrame.
  4. Memanggil model.
  5. Menampilkan hasil prediksi.
  6. Menampilkan probabilitas tertinggi.

32. Kode Lengkap Streamlit​

import streamlit as st
import pandas as pd
import joblib


st.set_page_config(
    page_title="Belajar Klasifikasi Jeruk",
    page_icon=":tangerine:",
)


# Memuat model yang sudah dilatih
model = joblib.load(
    "model_klasifikasi_jeruk.joblib"
)


st.title(":tangerine: Belajar Klasifikasi Jeruk")

st.markdown(
    "Aplikasi classification machine learning "
    "untuk memprediksi kualitas jeruk"
)


# Input numerik
diameter = st.slider(
    "Diameter",
    4.0,
    10.0,
    6.5
)

berat = st.slider(
    "Berat",
    100.0,
    250.0,
    175.0
)

tebal_kulit = st.slider(
    "Tebal Kulit",
    0.2,
    1.0,
    0.5
)

kadar_gula = st.slider(
    "Kadar Gula",
    10.0,
    15.0,
    12.5
)


# Input kategorikal
asal_daerah = st.pills(
    "Asal Daerah",
    [
        "Kalimantan",
        "Jawa Barat",
        "Jawa Tengah"
    ],
    default="Kalimantan"
)

warna = st.pills(
    "Warna",
    [
        "hijau",
        "kuning",
        "oranye"
    ],
    default="hijau"
)

musim_panen = st.pills(
    "Musim Panen",
    [
        "kemarau",
        "hujan"
    ],
    default="kemarau"
)


# Tombol prediksi
if st.button(
    "Predikasi",
    type="primary"
):

    data_baru = pd.DataFrame(
        [[
            diameter,
            berat,
            tebal_kulit,
            kadar_gula,
            asal_daerah,
            warna,
            musim_panen
        ]],
        columns=[
            'diameter',
            'berat',
            'tebal_kulit',
            'kadar_gula',
            'asal_daerah',
            'warna',
            'musim_panen'
        ]
    )


    # Melakukan prediksi
    prediction = model.predict(
        data_baru
    )[0]


    # Mengambil probabilitas terbesar
    persentase = max(
        model.predict_proba(
            data_baru
        )[0]
    )


    st.success(
        f"Model memprediksi **{prediction}** "
        f"dengan tingkat keyakinan "
        f"Persentase: "
        f"**{persentase * 100:.2f}%**"
    )


    st.balloons()


st.divider()

st.caption(
    "Demo aplikasi prediksi kualitas 🍊"
)

Kode aplikasi tersebut menggunakan model yang telah disimpan dari notebook.

Catatan: Pada kode asli terdapat teks tombol Predikasi. Untuk aplikasi publik, lebih baik menggunakan Prediksi agar lebih tepat secara bahasa.

33. Cara Kerja Aplikasi Streamlit​

Ketika pengguna membuka aplikasi:

Streamlit
   ↓
Load model_klasifikasi_jeruk.joblib
   ↓
Menampilkan form input

Pengguna kemudian memasukkan:

Diameter
Berat
Tebal Kulit
Kadar Gula
Asal Daerah
Warna
Musim Panen

Setelah tombol prediksi ditekan:

Input User
    ↓
DataFrame
    ↓
Pipeline
    ↓
Preprocessing
    ↓
Logistic Regression
    ↓
Prediction
    ↓
Hasil

34. Menjalankan Streamlit Secara Lokal​

Pastikan terminal berada pada folder project:

cd klasifikasi-jeruk

Kemudian jalankan:

streamlit run app.py

Biasanya Streamlit akan menjalankan aplikasi pada alamat lokal:

http://localhost:8501

Browser akan membuka halaman aplikasi.

35. Pengujian Aplikasi​

Sebelum melakukan deployment, aplikasi sebaiknya diuji secara lokal.

Checklist:

  • Model berhasil dimuat.
  • Semua slider dapat digunakan.
  • Semua pilihan kategori tersedia.
  • Tombol prediksi dapat ditekan.
  • Tidak terdapat error.
  • Prediksi muncul.
  • Persentase muncul.
  • Model memberikan hasil untuk beberapa kombinasi input.
  • Nama file model sesuai.
  • Semua dependency tersedia.

36. Membuat requirements.txt​

Aplikasi Streamlit membutuhkan daftar dependency agar environment deployment mengetahui library yang harus di-install.

Buat:

requirements.txt

Isi:

streamlit
pandas
scikit-learn
joblib

Jika menggunakan versi tertentu untuk memastikan kompatibilitas, versi package dapat ditentukan, misalnya:

streamlit==versi
pandas==versi
scikit-learn==versi
joblib==versi

Untuk deployment, penting memastikan versi library yang digunakan saat training kompatibel dengan environment tempat model digunakan.

37. Membuat README​

Buat file:

README.md

Contoh:

# Klasifikasi Kualitas Jeruk

Aplikasi machine learning untuk memprediksi
kualitas jeruk menggunakan Logistic Regression.

## Feature

- Diameter
- Berat
- Tebal Kulit
- Kadar Gula
- Asal Daerah
- Warna
- Musim Panen

## Target

- Bagus
- Sedang
- Jelek

## Teknologi

- Python
- Pandas
- Scikit-learn
- Joblib
- Streamlit

README membantu orang lain memahami tujuan repository.

38. Membuat Repository GitHub​

Buat repository baru di GitHub.

Contohnya:

klasifikasi-jeruk-streamlit

Struktur repository:

klasifikasi-jeruk-streamlit/
│
├── app.py
├── model_klasifikasi_jeruk.joblib
├── requirements.txt
└── README.md

Jika dataset tidak diperlukan saat aplikasi berjalan, dataset tidak wajib dimasukkan ke repository.

39. Inisialisasi Git​

Masuk ke folder project:

cd klasifikasi-jeruk

Kemudian:

git init

Tambahkan file:

git add .

Buat commit:

git commit -m "Initial Streamlit machine learning app"

40. Menghubungkan Project dengan GitHub​

Tambahkan remote repository:

git remote add origin https://github.com/USERNAME/klasifikasi-jeruk-streamlit.git

Kemudian:

git branch -M main

Push ke GitHub:

git push -u origin main

Setelah berhasil, file project akan tersedia di repository GitHub.

41. Mengapa GitHub Digunakan?​

GitHub bukan tempat menjalankan model.

GitHub digunakan sebagai repository untuk:

Source Code
Model
Requirements
Documentation
Version Control

Arsitekturnya:

Developer
   ↓
Git
   ↓
GitHub Repository
   ↓
Streamlit Community Cloud
   ↓
Streamlit Application

Dengan demikian GitHub menjadi sumber kode aplikasi.

42. Deployment Menggunakan Streamlit Community Cloud​

Setelah repository tersedia di GitHub, aplikasi dapat dideploy menggunakan Streamlit Community Cloud.

Alur deployment resmi Streamlit adalah memilih repository GitHub, branch, dan file aplikasi Streamlit. Streamlit kemudian melakukan proses deployment dan memberikan URL aplikasi.

Secara sederhana:

GitHub Repository
        ↓
Streamlit Community Cloud
        ↓
Install requirements.txt
        ↓
Menjalankan app.py
        ↓
Aplikasi Online

43. Login ke Streamlit Community Cloud​

Buka:

Streamlit Community Cloud

Kemudian login menggunakan akun yang terhubung dengan GitHub.

Streamlit menyediakan integrasi dengan GitHub untuk mengambil source code aplikasi.

44. Membuat Deployment Baru​

Setelah masuk ke Streamlit Community Cloud:

  1. Pilih opsi untuk membuat aplikasi baru.
  2. Pilih repository GitHub.
  3. Pilih branch.
  4. Tentukan file utama aplikasi.
  5. Konfigurasikan subdomain jika diperlukan.
  6. Jalankan deployment.

Untuk project ini:

Repository:
klasifikasi-jeruk-streamlit

Branch:
main

Main file:
app.py

Sehingga konfigurasi dasarnya:

Repository
    ↓
klasifikasi-jeruk-streamlit
    ↓
main
    ↓
app.py

Streamlit mendokumentasikan bahwa konfigurasi deployment mencakup repository, branch, dan file path aplikasi.

45. Apa yang Terjadi Saat Deployment?​

Ketika deployment dijalankan, platform perlu menyiapkan environment aplikasi.

Secara konseptual:

GitHub
  ↓
Clone Repository
  ↓
Baca requirements.txt
  ↓
Install Dependency
  ↓
Load app.py
  ↓
Load model_klasifikasi_jeruk.joblib
  ↓
Start Streamlit
  ↓
Aplikasi Online

Jadi file berikut sangat penting:

app.py
requirements.txt
model_klasifikasi_jeruk.joblib

46. Hasil Deployment​

Jika deployment berhasil, aplikasi akan mendapatkan alamat web pada domain Streamlit.

Contoh bentuk URL:

https://nama-aplikasi.streamlit.app

URL aktual akan bergantung pada nama aplikasi dan konfigurasi deployment.

Streamlit Community Cloud menggunakan domain streamlit.app untuk aplikasi yang dideploy.

info

Demo: https://demo-klasifikasi-jeruk.streamlit.app/

47. Update Aplikasi​

Salah satu keuntungan menggunakan GitHub adalah perubahan aplikasi dapat dilakukan melalui repository.

Misalnya kita mengubah:

st.title(":tangerine: Belajar Klasifikasi Jeruk")

menjadi:

st.title(":tangerine: Klasifikasi Kualitas Jeruk")

Kemudian:

git add .
git commit -m "Update application title"
git push

Repository berubah:

Local
  ↓
Git Push
  ↓
GitHub
  ↓
Streamlit
  ↓
Aplikasi diperbarui

Streamlit mendukung workflow berbasis GitHub, sehingga perubahan pada repository dapat digunakan untuk memperbarui aplikasi yang dideploy.

48. Arsitektur Keseluruhan Project​

Setelah deployment, keseluruhan sistem dapat digambarkan seperti berikut:

                 DEVELOPMENT
                      │
                      ▼
             ┌─────────────────┐
             │ Dataset Jeruk   │
             └────────┬────────┘
                      │
                      ▼
             ┌─────────────────┐
             │ Jupyter Notebook│
             └────────┬────────┘
                      │
          ┌───────────┴───────────┐
          ▼                       ▼
   Data Analysis            Model Training
                                  │
                                  ▼
                         Logistic Regression
                                  │
                                  ▼
                    model_klasifikasi_jeruk.joblib
                                  │
                                  ▼
                         ┌────────────────┐
                         │    GitHub      │
                         └───────┬────────┘
                                 │
                                 ▼
                    Streamlit Community Cloud
                                 │
                                 ▼
                         ┌───────────────┐
                         │ Streamlit App │
                         └───────┬───────┘
                                 │
                                 ▼
                              User
                                 │
                                 ▼
                         Prediksi Jeruk

49. Training vs Inference​

Hal penting dalam deployment machine learning adalah membedakan training dan inference.

Training​

Training dilakukan ketika membangun model:

Dataset
 ↓
Preprocessing
 ↓
Training
 ↓
Evaluation
 ↓
Save Model

Output:

model_klasifikasi_jeruk.joblib

Inference​

Inference dilakukan ketika aplikasi digunakan:

User Input
 ↓
Load Model
 ↓
Preprocessing
 ↓
Prediction
 ↓
Output

Aplikasi Streamlit tidak perlu melakukan training ulang.

50. Mengapa Tidak Melatih Model di Streamlit?​

Jika aplikasi melakukan training setiap kali dibuka:

User membuka aplikasi
        ↓
Load dataset
        ↓
Training model
        ↓
Model selesai
        ↓
Prediction

Hal tersebut dapat menyebabkan aplikasi menjadi lebih lambat dan tidak efisien.

Lebih baik:

TRAINING

Dataset
 ↓
Model
 ↓
Save


DEPLOYMENT

Load Model
 ↓
User Input
 ↓
Prediction

Pendekatan ini lebih sesuai untuk aplikasi inference sederhana.

51. Keterbatasan Model​

Walaupun model menghasilkan accuracy:

99%

hasil tersebut tidak boleh langsung dianggap sebagai bukti bahwa model akan selalu memiliki akurasi 99% pada data dunia nyata.

Beberapa alasan:

  • Dataset hanya terdiri dari 500 data.
  • Data testing hanya 100 data.
  • Dataset yang digunakan dalam eksperimen belum tentu mewakili seluruh kondisi jeruk di dunia nyata.
  • Performa dapat berubah ketika model menerima data dari sumber yang berbeda.
  • Probabilitas model bukan jaminan kebenaran.

Karena itu, model sebaiknya diuji kembali menggunakan data baru sebelum digunakan untuk keputusan produksi.

52. Masalah yang Sering Terjadi Saat Deployment​

Model tidak ditemukan​

Error:

FileNotFoundError:
model_klasifikasi_jeruk.joblib

Pastikan:

app.py
model_klasifikasi_jeruk.joblib

berada pada lokasi yang sesuai.

Library tidak ditemukan​

Contoh:

ModuleNotFoundError

Periksa:

requirements.txt

Pastikan library yang digunakan sudah dicantumkan.

Versi Scikit-learn bermasalah​

Model yang disimpan menggunakan versi tertentu dari Scikit-learn sebaiknya digunakan dengan versi yang kompatibel ketika model di-load.

Karena itu, untuk project yang lebih serius, catat dependency dan versinya.

Aplikasi berjalan lokal tetapi gagal di Streamlit​

Periksa:

requirements.txt
nama file
path file
versi Python
versi library
log deployment

Jangan hanya memeriksa app.py.

Deployment melibatkan environment yang berbeda dengan komputer lokal.

53. Pengembangan Selanjutnya​

Project ini dapat dikembangkan menjadi lebih kompleks.

Beberapa pengembangan yang dapat dilakukan:

Menambahkan visualisasi di aplikasi​

Misalnya:

Distribusi kualitas
Confusion matrix
Probabilitas prediksi
Statistik dataset

Membandingkan beberapa algoritma​

Misalnya:

Logistic Regression
Decision Tree
Random Forest
K-Nearest Neighbors
Support Vector Machine

Kemudian membandingkan:

Accuracy
Precision
Recall
F1-score

Menambahkan validasi input​

Misalnya memastikan:

Diameter > 0
Berat > 0
Kadar gula berada dalam range tertentu

Menambahkan model monitoring​

Jika aplikasi digunakan dalam skala lebih besar, model perlu dipantau terhadap:

  • perubahan distribusi data;
  • perubahan performa;
  • data baru;
  • data yang tidak sesuai pola training.

54. Alur Lengkap dari Notebook hingga Deployment​

Sekarang seluruh proses dapat dirangkum menjadi:

1. Dataset
      ↓
2. Load Dataset
      ↓
3. Data Understanding
      ↓
4. EDA
      ↓
5. Visualisasi
      ↓
6. Feature dan Target
      ↓
7. Train-Test Split
      ↓
8. Preprocessing
      ↓
9. Pipeline
      ↓
10. Logistic Regression
      ↓
11. Training
      ↓
12. Evaluation
      ↓
13. Prediction
      ↓
14. Save Model
      ↓
15. Streamlit
      ↓
16. Testing Local
      ↓
17. Git
      ↓
18. GitHub
      ↓
19. Streamlit Community Cloud
      ↓
20. Aplikasi Online

55. Struktur Final Repository​

Pada akhirnya repository dapat memiliki struktur:

klasifikasi-jeruk-streamlit/
│
├── app.py
│
├── model_klasifikasi_jeruk.joblib
│
├── requirements.txt
│
├── README.md
│
└── .gitignore

Jika notebook juga ingin disimpan:

klasifikasi-jeruk-streamlit/
│
├── app.py
├── model_klasifikasi_jeruk.joblib
├── requirements.txt
├── README.md
├── klasifikasi_jeruk.ipynb
└── .gitignore

56. Contoh .gitignore​

Untuk project Python:

__pycache__/
*.pyc
.ipynb_checkpoints/
.env
.venv/
venv/

Jika dataset tidak ingin di-upload:

jeruk_balance_500.csv

dapat ditambahkan ke .gitignore.

Namun, pastikan aplikasi memang tidak membutuhkan dataset tersebut saat inference.

57. Konsep Penting yang Dipelajari​

Project sederhana ini sebenarnya memperkenalkan banyak konsep machine learning sekaligus.

Data​

Dataset
Feature
Target

Data Understanding​

shape
columns
info
describe

EDA​

Scatter Plot
Analisis hubungan feature

Preprocessing​

StandardScaler
OneHotEncoder
OrdinalEncoder
ColumnTransformer

Modeling​

Pipeline
Logistic Regression

Evaluation​

Accuracy
Precision
Recall
F1-score
Confusion Matrix

Deployment​

Joblib
Streamlit
Git
GitHub
Streamlit Community Cloud

58. Kesimpulan​

Membangun machine learning bukan hanya tentang memilih algoritma dan menjalankan model.fit().

Sebuah project machine learning yang lengkap memiliki alur:

Data
 ↓
Understanding
 ↓
EDA
 ↓
Preprocessing
 ↓
Modeling
 ↓
Evaluation
 ↓
Prediction
 ↓
Deployment

Pada project ini kita menggunakan dataset 500 data dengan tujuh feature untuk memprediksi tiga kategori kualitas jeruk. Notebook menggunakan preprocessing berbeda untuk data numerik, kategorikal, dan ordinal, kemudian menggabungkannya dengan Logistic Regression menggunakan Pipeline.

Eksperimen pada notebook menghasilkan accuracy sebesar 0.99 pada 100 data testing, dengan classification report dan confusion matrix yang menunjukkan hanya satu kesalahan klasifikasi pada data testing.

Model kemudian disimpan menggunakan Joblib dan digunakan kembali oleh aplikasi Streamlit.

Akhirnya:

Jupyter Notebook
       ↓
Machine Learning Model
       ↓
Joblib
       ↓
Streamlit
       ↓
GitHub
       ↓
Streamlit Community Cloud
       ↓
Aplikasi Machine Learning Online

Inilah salah satu pola dasar yang penting untuk dipahami ketika mulai belajar machine learning deployment: model yang telah dilatih harus dapat dikemas menjadi sebuah aplikasi yang dapat menerima input baru dan menghasilkan prediksi.

59. Checklist Project​

Sebelum menganggap project selesai, pastikan:

Machine Learning​

  • Dataset berhasil dimuat
  • Data dipahami
  • EDA dilakukan
  • Visualisasi dibuat
  • Feature ditentukan
  • Target ditentukan
  • Train-test split dilakukan
  • Preprocessing dilakukan
  • Pipeline dibuat
  • Model dilatih
  • Model dievaluasi
  • Model diuji dengan data baru
  • Model disimpan

Deployment​

  • Streamlit dibuat
  • Model di-load
  • Input pengguna dibuat
  • Prediction dibuat
  • requirements.txt dibuat
  • Repository Git dibuat
  • Repository GitHub dibuat
  • Aplikasi diuji lokal
  • Aplikasi dideploy ke Streamlit Community Cloud

Dengan demikian, kita tidak hanya memiliki model machine learning, tetapi sebuah end-to-end machine learning application yang dapat digunakan melalui web.

Referensi​