---
# System prepended metadata

title: Intrusion Detection System (IDS) with ML Part II

---

# Intrusion Detection System (IDS) with ML Part II

## Tujuan
1. Peserta mengetahui cara melihat serangan dari data
2. Peserta memahami konsep model algoritma
3. Peserta memahami cara membuat IDS menggunakan Machine Learning

## 1. Random Forest
Random Forest adalah algoritma yang bekerja seperti “musyawarah dari banyak pohon keputusan.”
Bayangkan kamu punya satu pohon keputusan yang memberi keputusan “serangan” atau “normal”.
Kalau kamu punya 100 pohon, masing-masing akan memberi pendapatnya, dan hasil akhir ditentukan dengan suara terbanyak.

Contoh:
70 pohon bilang “serangan”, 30 pohon bilang “normal”

→ Hasil akhir: attack

Dengan banyak pohon, hasil prediksi menjadi lebih akurat dan stabil, karena tidak tergantung pada satu model saja.

### Cara kerja Random Forest
1. data dibagi secara acak menjadi beberapa bagian kecil
2. setiap bagian digunakan untuk melatih satu "pohon keputusan"
3. semua pohon belajar dengan sudut pandang berbeda
4. saat memprediksi, semua pohon memberikan "suara"/"voting", lalu hasil terbanyak jadi keputusan akhir

### Pros and Cons
(+) Pros
- mudah digunakan dan hasilnya biasanya bagus
- tidak mudah overfitting (artinya dia ga ngehafal data)
- cocok untuk data campuran (angka dan kategori)

(-) Cons
-    Proses training agak lama buat data yang besa
-    sulit dijelaskan bagaimana hasilnya terbentuk
-    memakai memori cukup besar

### Contoh kode singkat untuk membayangkannya
```python
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Buat model Random Forest
rf = RandomForestClassifier(
    n_estimators=100,   # jumlah pohon
    max_depth=10,       # kedalaman tiap pohon
    random_state=42
)

# Latih model
rf.fit(X_train, y_train)

# Prediksi hasil
y_pred = rf.predict(X_test)

# Lihat hasil evaluasi
print(classification_report(y_test, y_pred))
```

Penjelasan kedalaman pohon
Kedalaman tiap pohon (max_depth) adalah batas seberapa “dalam” sebuah pohon keputusan boleh berkembang.

Dalam satu pohon, setiap "cabang" dibuat berdasarkan keputusan tertentu
```css
Apakah jumlah paket > 100?
│
├── Ya → cek port yang digunakan
│     ├── Jika port 80 → Normal
│     └── Jika port 22 → Attack
│
└── Tidak → Normal
```

Jadi, semakin banyak pertanyaan berurutan seperti di atas, berarti pohonnya semakin dalam

Contohnya
- Pohon dengan kedalaman 2 hanya punya 2 pertanyaan sebelum sampai ke keputusan akhir.
- Pohon dengan kedalaman 10 bisa punya sampai 10 lapis pertanyaan (lebih detail, tapi bisa terlalu hafal data).



## 2. XGBoost
Kalau Random Forest seperti banyak orang voting bersama-sama, maka XGBoost adalah belajar dari kesalahan secara bertahap.

Bayangkan kamu sedang belajar menembak sasaran:
- Tembakan pertama meleset ke kiri.
- Tembakan kedua kamu perbaiki supaya lebih ke kanan.
- Tembakan ketiga makin akurat.

Nah, XGBoost bekerja dengan cara yang sama:
Model pertama membuat prediksi, model kedua memperbaiki kesalahannya, model ketiga memperbaiki lagi, dan seterusnya sampai hasilnya bagus.

### Kelebihan XGBoost apa aja sih wok?
-    Akurat karena setiap model memperbaiki kesalahan sebelumnya.
- Bisa menangani data yang hilang (missing value).
- Cepat dan efisien, cocok untuk dataset besar.
- Bisa memberi tahu fitur mana yang paling berpengaruh pada hasil deteksi.



## 3. CatBoost
CatBoost (Categorical Boosting) adalah salah satu algoritma gradient boosting modern yang dikembangkan oleh Yandex, perusahaan teknologi asal Rusia. CatBoost termasuk dalam keluarga ensemble learning berbasis decision tree, seperti halnya XGBoost dan LightGBM, tetapi memiliki keunggulan utama dalam menangani data kategorikal dan mencegah overfitting.

Nama “CatBoost” berasal dari dua kata yaitu, Cat yang artinya Categorical, karena algoritma ini bisa langsung menangani fitur kategorikal tanpa harus di-encode secara manual. Lalu Boost yang artinya Boosting, yaitu teknik membangun model kuat dari gabungan banyak model lemah (weak learners).

Sebelum masuk ke CatBoost, kita perlu memahami dulu konsep boosting.

`Boosting adalah teknik ensemble yang membangun model secara bertahap (sekuensial). Setiap model baru mencoba memperbaiki kesalahan dari model sebelumnya.`

Berikut cara kerja CatBoost:
![image](https://hackmd.io/_uploads/Sk0r2911Wl.png)

1. Model pertama dibuat → banyak salah.
1. Model kedua fokus pada data yang sebelumnya salah prediksi.
1. Model ketiga memperbaiki sisa kesalahan dari dua model sebelumnya.
1. Semua model digabungkan (dengan bobot tertentu) untuk menghasilkan prediksi akhir dengan loss seminimal mungkin.

CatBoost menggunakan varian Gradient Boosting on Decision Trees (GBDT), yang artinya setiap langkah boosting dilakukan dengan menyesuaikan gradien kesalahan dari model sebelumnya.

Berikut cara implementasi CatBoost:
```python
# Inisialisasi model CatBoost
cat_model = CatBoostClassifier(
    iterations=300,        # jumlah pohon
    learning_rate=0.1,     # laju pembelajaran
    depth=8,               # kedalaman pohon
    eval_metric='F1',
    random_seed=42,
    verbose=50
)

# Latih model
cat_model.fit(X_train, y_train)

# Prediksi
y_pred = cat_model.predict(X_test)

# Evaluasi hasil
print(classification_report(y_test, y_pred))
```

## 4. Ensemble Learning
Dalam dunia machine learning, Ensemble Learning adalah pendekatan yang menggabungkan beberapa model (disebut base learners) untuk menghasilkan performa prediksi yang lebih baik dibanding satu model saja. Ensemble Learning digunakan secara luas dalam sistem deteksi intrusi (IDS) karena satu algoritma saja (misalnya Random Forest atau XGBoost) kadang tidak cukup menangkap seluruh pola serangan.

Terdapat beberapa jenis Ensemble Learning, berikut adalah jenis-jenisnya:
| Jenis Ensemble                        | Konsep Utama                                                                                                                          | Contoh Model        | Karakteristik                                         |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | ----------------------------------------------------- |
| **Bagging (Bootstrap Aggregating)**   | Melatih banyak model pada subset data acak, lalu menggabungkan hasilnya dengan voting/average.                                        | Random Forest       | Mengurangi *variance*, mencegah overfitting.          |
| **Boosting**                          | Melatih model secara berurutan, di mana model baru memperbaiki kesalahan model sebelumnya.                                            | XGBoost, CatBoost   | Mengurangi *bias*, meningkatkan akurasi.              |
| **Stacking (Stacked Generalization)** | Menggabungkan beberapa model berbeda dan menggunakan model baru (meta-learner) untuk mempelajari cara terbaik menggabungkan prediksi. | Stacking Classifier | Menghasilkan performa terbaik, tetapi lebih kompleks. |

Berikut contoh cara kerja dari Ensemble Learning:
![image](https://hackmd.io/_uploads/SkIpsq1JWx.png)

* Model A (Random Forest) melihat dari sisi jumlah paket dan durasi koneksi.
* Model B (XGBoost) melihat dari rasio byte dan arah lalu lintas.
* Model C (CatBoost) melihat dari pola koneksi dan waktu antar paket.
* Lalu kita melakukan Ensemble Learning dengan menggabungkan model-model tersebut.


Masing-masing punya kelebihan dan kekurangan. Tapi jika ketiganya saling “membantu” melalui meta-model, hasil akhirnya akan lebih akurat dan lebih stabil.

Berikut cara implementasi Ensemble Learning:
```python
# Definisikan model dasar
rf = RandomForestClassifier(n_estimators=100, random_state=42)
xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42)
cat = CatBoostClassifier(iterations=200, depth=8, learning_rate=0.1, verbose=0, random_seed=42)

# Buat ensemble voting (soft)
ensemble = VotingClassifier(
    estimators=[('rf', rf), ('xgb', xgb), ('cat', cat)],
    voting='soft'
)

# Latih model ensemble
ensemble.fit(X_train, y_train)

# Prediksi
y_pred = ensemble.predict(X_test)

# Evaluasi performa
print(classification_report(y_test, y_pred))
```