Mengulik Statistik Pelabuhan - Kenapa Menggunakan LSTM daripada ARIMA

 

Wah ..grafik diatas sudah seperti hasil buku laporan Tugas Akhir mahasiswa saja ? Jadi jika pembaca mau menggunakan hasil karya saya tolong tulisan ini di quote atau sitasi ya ! Kini saya maju 10 langkah (guayane) menuju ke Long Short Term Memory ( opo artine yohh yohh?). Daripada mumet karena istilah yang semakin offside dari tukang solder, maka kita langsung aja menjelakan layaknya orang pinter, kenapa memilih LSTM ?

Memilih LSTM (Memori Jangka Pendek Panjang) daripada ARIMA untuk prediksi jangka panjang bergantung pada sifat data, kompleksitas hubungan yang ingin Anda modelkan, dan persyaratan khusus tugas peramalan Anda. Di bawah ini, saya akan menjelaskan mengapa LSTM sering kali lebih disukai untuk prediksi jangka panjang dalam skenario tertentu, terutama saat menangani data deret waktu yang kompleks atau multivariat.

1. Menangani Ketergantungan Jangka Panjang

ARIMA:

• ARIMA dirancang untuk memodelkan ketergantungan dan tren jangka pendek dalam deret waktu univariat.
• Ia sangat bergantung pada pengamatan terkini dan mungkin kesulitan untuk menangkap pola atau ketergantungan jangka panjang yang mencakup bulan atau tahun.
• Langkah pembedaan (d) dalam ARIMA membuatnya stasioner, yang dapat menghilangkan tren jangka panjang yang penting.

LSTM:

LSTM secara khusus dirancang untuk menangani ketergantungan jangka panjang dalam data sekuensial. Mereka menggunakan mekanisme gating (forget gate, input gate, output gate) untuk secara selektif menyimpan atau membuang informasi dalam urutan yang panjang, sehingga sangat cocok untuk menangkap pola temporal yang kompleks.

2. Input Multivariat

ARIMA:

• ARIMA pada dasarnya bersifat univariat, artinya ia bekerja dengan satu rangkaian waktu (misalnya, jumlah lalu lintas dari waktu ke waktu).
• Sementara ekstensi seperti SARIMAX memungkinkan variabel eksogen, ARIMA kesulitan untuk memodelkan interaksi kompleks antara beberapa fitur.

LSTM:

LSTM dapat menangani input multivariat, yang memungkinkan Anda untuk menggabungkan fitur tambahan seperti:

• Kondisi cuaca
• Liburan atau acara khusus
• Perubahan infrastruktur jalan
• Indikator ekonomi

Fleksibilitas ini membuat LSTM lebih kuat untuk skenario dunia nyata di mana beberapa faktor memengaruhi variabel target.

3. Non-Linearitas

ARIMA:

ARIMA mengasumsikan hubungan linear antara nilai masa lalu dan masa depan. Jika data yang mendasarinya menunjukkan pola non-linier (misalnya, lonjakan lalu lintas yang tiba-tiba karena suatu peristiwa), ARIMA mungkin gagal menangkap dinamika ini.

LSTM:

• LSTM mampu memodelkan hubungan non-linier dalam data.
• Arsitektur jaringan sarafnya memungkinkan mereka mempelajari pemetaan non-linier yang kompleks antara masukan dan keluaran.

4. Kemampuan Beradaptasi terhadap Pola yang Berubah

ARIMA:

• ARIMA mengasumsikan bahwa sifat statistik data (misalnya, rata-rata, varians) tetap konstan dari waktu ke waktu (stasioneritas).
• Jika data menunjukkan perubahan struktural (misalnya, karena pembangunan perkotaan, perubahan kebijakan, atau guncangan eksternal), ARIMA mungkin kesulitan untuk beradaptasi.

LSTM:

• LSTM dapat beradaptasi dengan pola yang berubah dalam data dengan belajar dari contoh-contoh historis.
• LSTM sangat berguna ketika data menunjukkan pergeseran rezim atau tren yang berkembang.

5. Skalabilitas

ARIMA:

ARIMA efisien secara komputasi dan bekerja dengan baik untuk kumpulan data berukuran kecil hingga menengah. Namun, model ini tidak dapat diskalakan dengan baik ke kumpulan data besar dengan data frekuensi tinggi (misalnya, hitungan lalu lintas tingkat menit).

LSTM:

• LSTM dapat menangani kumpulan data besar dan data frekuensi tinggi, sehingga cocok untuk aplikasi seperti pemantauan lalu lintas waktu nyata.
• Dengan kemajuan perangkat keras (GPU/TPU) dan pustaka seperti TensorFlow/PyTorch, pelatihan LSTM pada kumpulan data besar menjadi layak.

6. Fleksibilitas dalam Peramalan Horizon

ARIMA:

• ARIMA biasanya lebih cocok untuk prakiraan jangka pendek hingga menengah.
• Untuk prediksi jangka panjang, ketergantungan ARIMA pada pengamatan terkini dapat menyebabkan efek "garis datar", di mana model memprediksi nilai konstan dari waktu ke waktu.

LSTM:

• LSTM dapat dilatih untuk memprediksi beberapa langkah ke depan menggunakan teknik seperti:
• Peramalan Rekursif: Memprediksi satu langkah pada satu waktu dan memasukkan prediksi kembali ke dalam model.
• Peramalan Langsung: Melatih model untuk memprediksi semua langkah mendatang secara bersamaan. Fleksibilitas ini memungkinkan LSTM menangani prakiraan jangka panjang dengan lebih efektif.

7. Menggabungkan Informasi Kontekstual

ARIMA:

• ARIMA hanya berfokus pada deret waktu itu sendiri dan tidak memperhitungkan informasi kontekstual eksternal kecuali secara eksplisit disertakan sebagai variabel eksogen.
• Bahkan dengan variabel eksogen, ARIMA mungkin tidak sepenuhnya menangkap dampaknya jika hubungannya bersifat non-linier atau kompleks.

LSTM:

LSTM secara alami dapat menggabungkan informasi kontekstual, seperti:

• Waktu dalam sehari
• Hari dalam seminggu
• Efek musiman
• Regresor eksternal (misalnya, cuaca, hari libur)
• Kemampuan untuk mengintegrasikan berbagai masukan ini meningkatkan akurasi prediksi jangka panjang.

8. Prediksi Waktu Nyata

ARIMA:

ARIMA tidak cocok untuk prediksi waktu nyata karena memerlukan pelatihan ulang atau kalibrasi ulang saat data baru tiba.

LSTM:

Setelah dilatih, model LSTM dapat membuat prediksi waktu nyata dengan memproses data yang masuk secara berurutan. Ini sangat berguna untuk aplikasi seperti optimalisasi sinyal lalu lintas atau navigasi kendaraan otonom.

9. Visualisasi Pola Kompleks

ARIMA:

ARIMA memberikan hasil yang dapat diinterpretasikan tetapi terbatas pada pola sederhana seperti tren dan musim.

LSTM:

• Meskipun LSTM kurang dapat diinterpretasikan daripada ARIMA, LSTM dapat mengungkap pola tersembunyi dalam data yang tidak langsung terlihat.
• Alat visualisasi (misalnya, nilai SHAP, mekanisme perhatian) dapat membantu menginterpretasikan prediksi LSTM.

Kapan Memilih LSTM daripada ARIMA

Anda harus memilih LSTM daripada ARIMA untuk prediksi jangka panjang ketika:

• Data bersifat multivariat: Anda memiliki fitur tambahan (misalnya, cuaca, peristiwa) yang memengaruhi variabel target.
• Data menunjukkan pola non-linier: Hubungan antara masukan dan keluaran bersifat kompleks dan tidak dapat ditangkap oleh model linier.
• Cakrawala prakiraan panjang: Anda memerlukan prediksi untuk beberapa minggu, bulan, atau tahun mendatang.
• Data bersifat non-stasioner atau berkembang seiring waktu: Pola yang mendasarinya berubah karena faktor eksternal.
• Anda memiliki akses ke kumpulan data besar: Model LSTM memerlukan data yang cukup untuk pelatihan yang efektif.

Kapan Harus Menggunakan ARIMA?

Terlepas dari keterbatasannya, ARIMA tetap menjadi pilihan yang baik untuk:

• Prakiraan jangka pendek hingga menengah: Ketika cakrawala terbatas (misalnya, jam hingga minggu).
• Data univariat: Ketika Anda hanya memiliki satu deret waktu untuk digunakan.
• Interpretabilitas: Ketika Anda memerlukan wawasan yang jelas tentang perilaku model.
• Efisiensi komputasi: Ketika bekerja dengan kumpulan data kecil atau sumber daya terbatas.

Kesimpulan

Singkatnya, LSTM secara umum lebih cocok untuk prediksi jangka panjang ketika datanya kompleks, multivariat, atau non-linier. Ia menawarkan fleksibilitas dan skalabilitas yang lebih besar dibandingkan dengan ARIMA, terutama untuk aplikasi dunia nyata seperti prakiraan lalu lintas. Namun, ARIMA tetap menjadi alat yang berharga untuk skenario yang lebih sederhana atau ketika interpretabilitas menjadi prioritas.

Jika Anda tidak yakin model mana yang akan digunakan, Anda dapat bereksperimen dengan keduanya dan membandingkan kinerjanya menggunakan metrik seperti RMSE, MAE, atau MAPE. Beri tahu saya jika Anda memerlukan bantuan dalam mengimplementasikan salah satu model tersebut pada kumpulan data Anda!

Wahhh ribet bukan ? apalagi kalau melihat hasil proses training modelnya ...Ngeriiii:

Epoch 1/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 4s 38ms/step - loss: 0.1231
Epoch 2/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0932
Epoch 3/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0877
Epoch 4/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0459
Epoch 5/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0452
Epoch 6/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0419
Epoch 7/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 37ms/step - loss: 0.0406
Epoch 8/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0413
Epoch 9/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0422
Epoch 10/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0360
Epoch 11/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0387
Epoch 12/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0406
Epoch 13/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 40ms/step - loss: 0.0369
Epoch 14/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0375
Epoch 15/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0392
Epoch 16/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 40ms/step - loss: 0.0432
Epoch 17/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0423
Epoch 18/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step - loss: 0.0432
Epoch 19/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0372
Epoch 20/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0404
Epoch 21/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 39ms/step - loss: 0.0368
Epoch 22/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0370
Epoch 23/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step - loss: 0.0360
Epoch 24/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0377
Epoch 25/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0373
Epoch 26/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0357
Epoch 27/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0361
Epoch 28/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0341
Epoch 29/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0385
Epoch 30/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0355
Epoch 31/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0391
Epoch 32/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step - loss: 0.0398
Epoch 33/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 51ms/step - loss: 0.0383
Epoch 34/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 52ms/step - loss: 0.0357
Epoch 35/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 53ms/step - loss: 0.0392
Epoch 36/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 0.0360
Epoch 37/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 52ms/step - loss: 0.0382
Epoch 38/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step - loss: 0.0357
Epoch 39/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 0.0409
Epoch 40/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 0.0390
Epoch 41/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 52ms/step - loss: 0.0386
Epoch 42/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 58ms/step - loss: 0.0394
Epoch 43/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0420
Epoch 44/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0402
Epoch 45/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0340
Epoch 46/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0368
Epoch 47/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0411
Epoch 48/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0341
Epoch 49/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0369
Epoch 50/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0439
Epoch 51/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0359
Epoch 52/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0375
Epoch 53/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0374
Epoch 54/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0379
Epoch 55/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0376
Epoch 56/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0356
Epoch 57/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0377
Epoch 58/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0379
Epoch 59/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0367
Epoch 60/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0358
Epoch 61/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0372
Epoch 62/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0384
Epoch 63/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0362
Epoch 64/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0349
Epoch 65/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0420
Epoch 66/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0356
Epoch 67/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0393
Epoch 68/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0427
Epoch 69/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0386
Epoch 70/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0375
Epoch 71/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0365
Epoch 72/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0352
Epoch 73/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0387
Epoch 74/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0365
Epoch 75/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0363
Epoch 76/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0355
Epoch 77/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0358
Epoch 78/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0347
Epoch 79/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0363
Epoch 80/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0370
Epoch 81/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0359
Epoch 82/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0399
Epoch 83/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0348
Epoch 84/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0328
Epoch 85/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0377
Epoch 86/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0364
Epoch 87/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0353
Epoch 88/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0364
Epoch 89/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step - loss: 0.0406
Epoch 90/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0318
Epoch 91/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 54ms/step - loss: 0.0393
Epoch 92/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 0.0417
Epoch 93/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 53ms/step - loss: 0.0385
Epoch 94/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 52ms/step - loss: 0.0373
Epoch 95/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 59ms/step - loss: 0.0341
Epoch 96/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 63ms/step - loss: 0.0360
Epoch 97/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 60ms/step - loss: 0.0375
Epoch 98/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 62ms/step - loss: 0.0354
Epoch 99/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step - loss: 0.0372
Epoch 100/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 39ms/step - loss: 0.0370
Epoch 1/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 4s 31ms/step - loss: 0.0773
Epoch 2/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0583
Epoch 3/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0465
Epoch 4/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0398
Epoch 5/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0248
Epoch 6/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0192
Epoch 7/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0179
Epoch 8/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0206
Epoch 9/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step - loss: 0.0195
Epoch 10/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0201
Epoch 11/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0181
Epoch 12/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 41ms/step - loss: 0.0171
Epoch 13/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0190
Epoch 14/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0177
Epoch 15/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0158
Epoch 16/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0162
Epoch 17/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0181
Epoch 18/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0200
Epoch 19/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0186
Epoch 20/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0165
Epoch 21/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 40ms/step - loss: 0.0170
Epoch 22/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0190
Epoch 23/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0191
Epoch 24/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0179
Epoch 25/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0187
Epoch 26/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0182
Epoch 27/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 37ms/step - loss: 0.0164
Epoch 28/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0181
Epoch 29/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0185
Epoch 30/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0203
Epoch 31/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 58ms/step - loss: 0.0153
Epoch 32/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step - loss: 0.0159
Epoch 33/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 0.0159
Epoch 34/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step - loss: 0.0175
Epoch 35/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 0.0184
Epoch 36/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step - loss: 0.0149
Epoch 37/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 61ms/step - loss: 0.0164
Epoch 38/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 55ms/step - loss: 0.0181
Epoch 39/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 62ms/step - loss: 0.0181
Epoch 40/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 65ms/step - loss: 0.0159
Epoch 41/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 37ms/step - loss: 0.0177
Epoch 42/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 39ms/step - loss: 0.0158
Epoch 43/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0150
Epoch 44/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0179
Epoch 45/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0156
Epoch 46/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 41ms/step - loss: 0.0179
Epoch 47/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 76ms/step - loss: 0.0171
Epoch 48/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0163
Epoch 49/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 73ms/step - loss: 0.0185
Epoch 50/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0166
Epoch 51/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0164
Epoch 52/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0165
Epoch 53/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 40ms/step - loss: 0.0189
Epoch 54/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0152
Epoch 55/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0154
Epoch 56/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 39ms/step - loss: 0.0173
Epoch 57/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0164
Epoch 58/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0161
Epoch 59/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0161
Epoch 60/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0161
Epoch 61/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0156
Epoch 62/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0182
Epoch 63/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0160
Epoch 64/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0166
Epoch 65/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0192
Epoch 66/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0172
Epoch 67/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 38ms/step - loss: 0.0180
Epoch 68/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0143
Epoch 69/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0148
Epoch 70/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0179
Epoch 71/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 0.0142
Epoch 72/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0152
Epoch 73/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0171
Epoch 74/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0156
Epoch 75/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0155
Epoch 76/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0150
Epoch 77/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step - loss: 0.0163
Epoch 78/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0168
Epoch 79/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0145
Epoch 80/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 40ms/step - loss: 0.0155
Epoch 81/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0157
Epoch 82/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 35ms/step - loss: 0.0162
Epoch 83/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 54ms/step - loss: 0.0148
Epoch 84/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 55ms/step - loss: 0.0185
Epoch 85/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step - loss: 0.0177
Epoch 86/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 49ms/step - loss: 0.0144
Epoch 87/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 0.0159
Epoch 88/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 60ms/step - loss: 0.0169
Epoch 89/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 54ms/step - loss: 0.0176
Epoch 90/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 53ms/step - loss: 0.0164
Epoch 91/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 52ms/step - loss: 0.0140
Epoch 92/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 52ms/step - loss: 0.0150
Epoch 93/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step - loss: 0.0167
Epoch 94/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0198
Epoch 95/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0160
Epoch 96/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 37ms/step - loss: 0.0158
Epoch 97/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0159
Epoch 98/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0157
Epoch 99/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 36ms/step - loss: 0.0169
Epoch 100/100
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 34ms/step - loss: 0.0144
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 379ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 46ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 47ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 47ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 46ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 46ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 49ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 41ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 41ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 45ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 55ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 49ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 47ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 52ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 42ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 55ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 55ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step

Namun hasilnya bisa diakui lebih keren kok ...

Karena kodingnya yang panjang-panjang apalagi harus menerjemahkan data json terlebih dulu dari API BPS, ditambah  dengan data tiap pelabuhan yang memiliki 2 buah data time series kedatangan dan keberangkatan, jadi bagi pembaca yang ingin mengutak-atik lebih dalam saya sarankan menghubungi penulis blog di 08155737755.

-powered by QWEN AI-

Read More

Mengulik Statistik Transportasi KAI - Regresi Linear Vs ARIMA

 

Pembahasan kali ini akan mengambil data yang telah disediakan oleh Biro Pusat Statistik yang memang diperintahkan oleh negara untuk menyediakan data-data statistik semua kegiatan penduduk Indonesia, salah satunya yang saya ambil adalah data perjalanan kereta api yang tersedia sejak 2006. Jadi jika pembaca ingin belajar lewat contoh-contoh seperti yang saya gunakan, bisa mendaftar API key secara gratis di websitenya BPS. Memang sih tiap data bisa diambil dalam excel atau csv, namun ketersediaanya dalam bentuk tahunan, sehingga gak terlalu keren untuk unjuk gigi kemampuan koding saya (padahal saya juga banyak dibantu QWENAI).

Contoh untuk memanggi API dan mendapatkan JSON nya bisa menggunakan script python seperti ini :

koding:

#Jangan lupa daftar akses API key di BPS
import requests
r = requests.get('https://webapi.bps.go.id/v1/api/list/model/data/lang/ind/domain/0000/var/72/key/Ubah key punya akun anda')
with open('data_KAI.json','w') as fd:
    fd.write(r.text)

Namun ...bukan Indonesia namanya kalau menyediakan data gratisan apapun dengan prinsip "Kalau bisa dipersulit ngapain dipermudah ?" Jadi JSON nya sepertinya hanya dipahami yang bikin database dari BPS, dimana tiap key json saling terhubung dengan kode-kode yang saling terkait. Jadi jika menggunakan layanan Json to Table di internet, maka akan zonk hasilnya. Jadi saya bertanya aja ke QWEN AI dan mendapatkan pencerahan mengenai Json dari API BPS, dan berhasil membuat CSV yang lebih gampang di extract time-series nya.

File JSON ini berisi kumpulan data komprehensif terkait transportasi, khususnya yang berfokus pada jumlah penumpang kereta api di Indonesia. Data tersebut terstruktur dan saling terhubung melalui berbagai kunci dan nilai. Berikut ini adalah analisis struktur dan koneksi dalam JSON:

Struktur Umum

Metadata:

• status: Menunjukkan status data (misalnya, "OK").
• data-availability: Menunjukkan apakah data tersedia.
• last_update: Stempel waktu pembaruan terakhir.

Subjek:

• subject: Berisi informasi tentang subjek data, dalam hal ini, "Transportasi".

Variabel:

• var: Menjelaskan variabel yang sedang diukur. Di sini, "Jumlah Penumpang Kereta Api" dengan satuan "Ribu Orang". Ini juga mencakup catatan dan sumber.

Variabel Versi:

• turvar: Atribut tambahan untuk pembuatan versi (dalam hal ini, menunjukkan 'Tidak'). 
• labelvervar: Label untuk jenis transportasi ("Kereta Api").
• vervar: Mencantumkan berbagai jenis layanan kereta api seperti Jabodetabek, Non Jabodetabek, Sumatera, dll.

Tahun:

• tahun: Mencantumkan tahun dari 2006 hingga 2025.

Periode Waktu:

• turtahun: Mencantumkan bulan dan entri tahunan.

Konten Data:

• datacontent: Berisi titik data aktual. Setiap kunci mewakili kombinasi variabel dan periode waktu tertentu, dan nilainya mewakili jumlah penumpang.

Data Terkait:

• related: Bagian ini kosong di berkas Anda, tetapi dapat digunakan untuk menautkan ke kumpulan data terkait lainnya.

Koneksi dan Hubungan Kunci:

Keterkaitan Subjek dan Variabel:

• Array subjek terhubung ke array var melalui kolom subj. Misalnya, "Transportasi" terhubung ke "Jumlah Penumpang Kereta Api".

Variabel dan Variabel Versi:

• Array var dirinci lebih lanjut oleh array vervar yang mengkategorikan data ke dalam berbagai jenis layanan kereta api.

Data Temporal:

• Array tahun dan turtahun menyediakan konteks temporal. Setiap titik data dalam datacontent sesuai dengan tahun dan bulan tertentu (atau tahunan).

Titik Data:

Kunci dalam datacontent mengikuti pola yang mengodekan jenis layanan, tahun, dan bulan. Misalnya, 17201061 dapat dipecah menjadi:

• 1: Mengacu pada "Jabodetabek" dari vervar.
• 72: Mengacu pada "Jumlah Penumpang Kereta Api".
• 01: Mengacu pada tahun 2006 dari tahun.
• 06: Mengacu pada Juni dari turtahun.

Contoh Analisis:

Mari kita ambil contoh kunci dari datacontent untuk mengilustrasikan bagaimana data saling terhubung:

Kunci: 17201061

Rincian:

• 1: "Jabodetabek" (vervar)
• 72: "Jumlah Penumpang Kereta Api" (var)
• 01: Tahun 2006 (tahun)
• 06: Bulan Juni (turtahun)
• Nilai: 8681 (yang berarti 8.681.000 penumpang)

Ringkasan:

File JSON sangat terstruktur dan saling terhubung, memungkinkan analisis terperinci jumlah penumpang kereta api di berbagai layanan, tahun, dan bulan. Kunci dalam objek datacontent mengodekan dimensi ini, sehingga memungkinkan untuk mengekstrak wawasan yang berarti tentang tren dan pola dalam transportasi kereta api dari waktu ke waktu.

Nah...mumet bukan ? Mari kita lanjutkan ke script python yang sudah saya sesuaikan agar bisa merubah json BPS menjadi CSV data series:

# Import required libraries
import pandas as pd
import json
with open('data_KAI.json', 'r') as file:
    data = json.load(file)

# Extract relevant mappings
vervar_map = {str(v['val']): v['label'] for v in data['vervar']}  # Train services
tahun_map = {str(t['val']): t['label'] for t in data['tahun']}  # Years
turtahun_map = {str(t['val']): t['label'] for t in data['turtahun']}  # Months + Annual
# Prepare a dictionary to store the decoded data
time_series_data = {}
# Decode the datacontent keys
for key, value in data['datacontent'].items():
    # Split the key into components
    service_code = key[0]  # First digit: service type
    year_code = key[4:7]   # Next three digits: year
    month_code = key[7:]   # Remaining digits: month or annual
    #print(year_code)
    # Map codes to labels
    service_label = vervar_map.get(service_code, "Unknown Service")
    year_label = tahun_map.get(year_code, "Unknown Year")  # Use full year_code for lookup
    month_label = turtahun_map.get(month_code, "Unknown Month")
    # Create a unique identifier for the column (YYYY-MM format)
    if month_label != "Tahunan":  # Exclude annual data
        date_key = f"{year_label}-{int(month_code):02d}"  # Format: YYYY-MM
    else:
        date_key = f"{year_label}-Annual"  # For annual totals
    # Add to the time_series_data dictionary
    if service_label not in time_series_data:
        time_series_data[service_label] = {}
    time_series_data[service_label][date_key] = value
# Convert to a DataFrame
all_dates = sorted({date for dates in time_series_data.values() for date in dates})
df = pd.DataFrame(index=time_series_data.keys(), columns=all_dates)
# Populate the DataFrame
for service, values in time_series_data.items():
    for date, count in values.items():
        df.at[service, date] = count
# Reset index to make the services a column
df.reset_index(inplace=True)
df.rename(columns={"index": "Service"}, inplace=True)
# Save the DataFrame to a CSV file
csv_file = "railway_passenger_time_series.csv"
df.to_csv(csv_file, index=False)
print(f"CSV file '{csv_file}' has been created successfully!")

Hasilnya berupa file bernama "railway_passenger_time_series.csv" dan untuk menampilkan data nya dalam visualisasi grafik, kita manfaatkan matplotlib. Seperti contoh dibawah ini mengambarkan data history perjalanan kereta api di daerah jabodetabek periode 2006-2025 (grafik ada di gambar paling atas):

# Import required libraries
import pandas as pd
import matplotlib.pyplot as plt
# Load the previously created CSV file
csv_file = "railway_passenger_time_series.csv"
df = pd.read_csv(csv_file)
# Filter data for "Jabodetabek" service
jabodetabek_data = df[df['Service'] == 'Jabodetabek'].drop(columns=['Service']).T
jabodetabek_data.columns = ['PassengerCount']
# Remove rows corresponding to "Year-Annual" (filter out annual totals)
jabodetabek_data = jabodetabek_data[~jabodetabek_data.index.str.contains('Annual')]
jabodetabek_data.index = pd.to_datetime(jabodetabek_data.index, format='%Y-%m')  # Convert index to datetime
jabodetabek_data = jabodetabek_data.sort_index()  # Ensure chronological order
# Plot the time series data
plt.figure(figsize=(14, 7))
plt.plot(jabodetabek_data.index, jabodetabek_data['PassengerCount'], label='Jabodetabek Passenger Count', color='blue')
# Add title and labels
plt.title('Monthly Passenger Count for Jabodetabek (2006-2025)', fontsize=16)
plt.xlabel('Year', fontsize=12)
plt.ylabel('Passenger Count (in thousands)', fontsize=12)
# Rotate x-axis labels for better readability
plt.xticks(rotation=45)
# Add grid and legend
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()
# Show the plot
plt.tight_layout()
plt.show()

Ayo jangan lama-lama saya tampilkan regesi linearnya :

# Import required libraries
import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
# Load the previously created CSV file
csv_file = "railway_passenger_time_series.csv"
df = pd.read_csv(csv_file)
# Filter data for "Jabodetabek" service
jabodetabek_data = df[df['Service'] == 'Jabodetabek'].drop(columns=['Service']).T
jabodetabek_data.columns = ['PassengerCount']
# Remove rows corresponding to "Year-Annual" (filter out annual totals)
jabodetabek_data = jabodetabek_data[~jabodetabek_data.index.str.contains('Annual')]
# Convert index to datetime format
jabodetabek_data.index = pd.to_datetime(jabodetabek_data.index, format='%Y-%m')
jabodetabek_data = jabodetabek_data.sort_index()  # Ensure chronological order
# Filter data for the years 2020 to 2024
start_date = '2006-01'
end_date = '2024-12'
filtered_data = jabodetabek_data.loc[start_date:end_date]
# Prepare the data for training
def prepare_data(series):
    """
    Prepare data for supervised learning.
    :param series: Time series data (passenger counts).
    :return: X (features) and y (target).
    """
    X, y = [], []
    for i in range(len(series) - 1):  # Use one-step-ahead prediction
        X.append([i])  # Use time step as the feature
        y.append(series[i + 1])  # Predict the next month
    return np.array(X), np.array(y)
# Extract the passenger count series
series = filtered_data['PassengerCount'].values
# Prepare training datasets
X_train, y_train = prepare_data(series)
# Train the Linear Regression model
model = LinearRegression()
model.fit(X_train, y_train)
# Predict future values for the next 60 months (2029)
future_months = 60
last_time_step = len(series) - 1
future_predictions = []
for i in range(future_months):
    next_month_prediction = model.predict([[last_time_step + i]])[0]
    future_predictions.append(next_month_prediction)
# Create a DataFrame for the predictions
future_dates = pd.date_range(start=filtered_data.index[-1] + pd.offsets.MonthBegin(),
                             periods=future_months, freq='MS')
predictions_df = pd.DataFrame({
    'Date': future_dates,
    'Predicted_PassengerCount': future_predictions
})
# Combine historical data and predictions
combined_data = pd.concat([
    filtered_data.reset_index().rename(columns={'index': 'Date'}),
    predictions_df
])
# Plot the results
plt.figure(figsize=(14, 7))
# Historical data
plt.plot(combined_data['Date'][:-future_months], combined_data['PassengerCount'][:-future_months],
         label='Historical Data (2006-2024)', color='blue')
# Predictions
plt.plot(combined_data['Date'][-future_months:], combined_data['Predicted_PassengerCount'][-future_months:],
         label='Predicted Data (2025)', color='orange', linestyle='--')
# Add title and labels
plt.title('Monthly Passenger Count for Jabodetabek (2006-2029)', fontsize=16)
plt.xlabel('Year', fontsize=12)
plt.ylabel('Passenger Count (in thousands)', fontsize=12)
# Rotate x-axis labels for better readability
plt.xticks(rotation=45)
# Add grid and legend
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()
# Show the plot
plt.tight_layout()
plt.show()

Hasilnya seperti ini grafiknya :

Bagaimana dengan ARIMA ?

# Create a DataFrame for the predictions
future_dates = pd.date_range(start=filtered_data.index[-1] + pd.offsets.MonthBegin(),
                             periods=future_months, freq='MS')
predictions_df = pd.DataFrame({
    'Date': future_dates,
    'Predicted_PassengerCount': predictions
})
# Combine historical data and predictions
combined_data = pd.concat([
    filtered_data.reset_index().rename(columns={'index': 'Date'}),
    predictions_df
])
# Plot the results
plt.figure(figsize=(14, 7))
# Historical data
plt.plot(combined_data['Date'][:-future_months], combined_data['PassengerCount'][:-future_months],
         label=f'Historical Data ({start_date[0:4]}-{end_date[0:4]})', color='blue')
# Predictions
plt.plot(combined_data['Date'][-future_months:], combined_data['Predicted_PassengerCount'][-future_months:],
         label='Predicted Data (2025)', color='orange', linestyle='--')
# Add title and labels
plt.title(f'Monthly Passenger Count for Jabodetabek ({start_date[0:4]}-{end_date[0:4]})', fontsize=16)
plt.xlabel('Year', fontsize=12)
plt.ylabel('Passenger Count (in thousands)', fontsize=12)
# Rotate x-axis labels for better readability
plt.xticks(rotation=45)
# Add grid and legend
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()
# Show the plot
plt.tight_layout()
plt.show()

Grafiknya lebih bergejolak dibandingkan regresi linear :

Pada grafik diatas bisa pembaca utak-atik range tahun yang digunakan karena ada pola yang kurang "statisioner" ketika jaman pandemi 2020-2021.

Jika prediksi dari model Anda (misalnya, ARIMA, LSTM, atau model peramalan lainnya) menghasilkan garis 'cenderung' datar, biasanya hal ini menunjukkan bahwa model tersebut gagal menangkap pola, tren, atau kemusiman yang mendasarinya dalam data. Prediksi garis datar menunjukkan bahwa model tersebut memprediksi nilai konstan dari waktu ke waktu, yang sering kali merupakan tanda adanya satu atau beberapa masalah dalam proses pemodelan. Berikut adalah alasan paling umum untuk perilaku ini dan cara mengatasinya:

1. Kurangnya Tren atau Kemusiman dalam Data

Mengapa hal ini terjadi: Jika data historis tidak menunjukkan tren atau kemusiman yang kuat, model tersebut mungkin secara default memprediksi nilai konstan (misalnya, rata-rata data).

Cara memperbaikinya:

• Visualisasikan data untuk memeriksa tren, kemusiman, atau pola siklus.
• Gunakan teknik dekomposisi (misalnya, seasonal_decompose dalam Python) untuk menganalisis komponen deret waktu. Jika tren atau kemusiman ada tetapi lemah, pertimbangkan untuk memodelkannya secara eksplisit menggunakan alat seperti:
• Menambahkan komponen musiman dalam ARIMA (SARIMA).
• Menggunakan fitur eksternal (misalnya, hari dalam seminggu, hari libur) dalam model pembelajaran mesin.

2. Konfigurasi Model yang Buruk

Mengapa hal ini terjadi: Parameter model mungkin tidak disetel dengan benar, yang menyebabkan underfitting. Misalnya:

• Dalam ARIMA, parameter (p, d, q) mungkin tidak optimal.
• Dalam LSTM, arsitektur (misalnya, jumlah lapisan, neuron) atau hiperparameter (misalnya, laju pembelajaran, ukuran batch) mungkin tidak sesuai dengan data.

Cara memperbaikinya:

• Untuk ARIMA, gunakan alat seperti auto_arima untuk menemukan parameter terbaik secara otomatis.
• Untuk LSTM, bereksperimenlah dengan arsitektur, laju pembelajaran, dan durasi pelatihan yang berbeda.
• Validasi model secara teratur menggunakan metrik seperti RMSE atau MAE pada set validasi.

3. Data Tidak Cukup

Mengapa hal ini terjadi: Jika kumpulan data terlalu kecil atau tidak memiliki variabilitas, model mungkin kesulitan mempelajari pola yang bermakna.

Cara memperbaikinya:

• Pastikan Anda memiliki cukup data historis untuk melatih model secara efektif.
• Jika datanya jarang, pertimbangkan untuk menggabungkannya (misalnya, harian → mingguan) untuk mengurangi gangguan dan menyorot pola.

4. Pemulusan Berlebihan Selama Prapemrosesan

Mengapa hal ini terjadi: Langkah-langkah prapemrosesan seperti pemulusan berlebihan, pembedaan, atau normalisasi dapat menghilangkan pola penting dari data.

Cara memperbaikinya:

• Hindari pembedaan berlebihan pada data dalam ARIMA (gunakan d minimum yang diperlukan untuk mencapai stasioneritas).
• Berhati-hatilah dengan normalisasi. Misalnya, jika rentang nilai terlalu padat, model mungkin memprediksi mendekati rata-rata.
• Pertahankan skala asli data saat mengevaluasi prediksi. 

5. Model Memprediksi Rata-rata

Mengapa hal ini terjadi: Banyak model, terutama yang lebih sederhana seperti ARIMA, cenderung memprediksi rata-rata data ketika tidak dapat mengidentifikasi pola yang jelas.

Cara memperbaikinya:

• Tambahkan regresor eksternal (misalnya, cuaca, hari libur) untuk memberikan konteks tambahan.
• Gunakan model yang lebih kompleks seperti LSTM atau peningkatan gradien yang dapat mempelajari hubungan non-linier.
• Periksa residual model untuk memastikannya acak. Jika residual menunjukkan pola, model tersebut kurang sesuai.

6. Fitur Input yang Salah

Mengapa hal ini terjadi: Jika fitur input tidak cukup mewakili dependensi temporal, model mungkin gagal untuk belajar.

Cara memperbaikinya:

• Sertakan fitur yang tertinggal (misalnya, pengamatan sebelumnya) untuk model pembelajaran mesin.
• Gunakan pengetahuan domain untuk merekayasa fitur yang bermakna (misalnya, rata-rata bergulir, indikator hari dalam seminggu). 

7. Evaluasi pada Pola yang Tak Terlihat

Mengapa hal ini terjadi: Jika data pengujian berisi pola yang tidak terlihat dalam data pelatihan, model mungkin akan menggunakan prediksi datar secara default.

Cara memperbaikinya:

• Pastikan set data pelatihan dan pengujian berasal dari distribusi yang sama.
• Gunakan teknik validasi silang seperti pemisahan deret waktu untuk mengevaluasi kinerja model pada data yang tak terlihat.

8. Regresor Eksternal yang Konstan

Mengapa hal ini terjadi: Jika fitur eksternal (misalnya, cuaca, peristiwa) konstan atau tidak memiliki variabilitas, model mungkin tidak mempelajari hubungan yang bermakna.

Cara memperbaikinya:

• Pastikan fitur eksternal memiliki variabilitas dan relevansi yang cukup terhadap variabel target.
• Hapus fitur yang tidak relevan atau konstan dari set data.

9. Pelatihan pada Cakrawala yang Terlalu Pendek

Mengapa hal ini terjadi: Jika model dilatih pada urutan yang sangat pendek atau cakrawala prakiraan yang terbatas, model mungkin gagal untuk digeneralisasi ke cakrawala yang lebih panjang.

Cara memperbaikinya:

• Latih model pada urutan yang lebih panjang atau perluas cakrawala prakiraan selama pelatihan.
• Gunakan teknik peramalan multi-langkah (misalnya, peramalan rekursif atau langsung) untuk prediksi jangka panjang.

10. Kebocoran Data

Mengapa hal ini terjadi: Jika informasi masa depan bocor ke dalam data pelatihan, model mungkin gagal untuk digeneralisasi dan menghasilkan prediksi yang tidak realistis.

Cara memperbaikinya:

• Pastikan set pelatihan dan pengujian dipisahkan secara ketat dalam waktu.
• Hindari penggunaan data masa depan (misalnya, nilai target) sebagai fitur selama pelatihan.

- Powered by Qwen AI -

Read More

Mengulik Statistik Transportasi - Prediksi Deret Waktu Dengan ARIMA

 

Untuk mengikuti tulisan kali ini diharapkan membaca dulu bagian scraping data agar contoh dataset yang digunakan  dapat diambil dengan benar ...( baca disini )

ARIMA (AutoRegressive Integrated Moving Average) adalah model statistik yang banyak digunakan untuk peramalan deret waktu. Model ini sangat efektif untuk data deret waktu univariat, yang tujuannya adalah untuk memprediksi nilai masa depan berdasarkan pengamatan masa lalu. Dalam konteks prediksi lalu lintas, ARIMA dapat digunakan untuk meramalkan parameter lalu lintas seperti jumlah kendaraan, kecepatan, atau tingkat kemacetan di persimpangan atau di sepanjang ruas jalan.

Di bawah ini, saya akan menjelaskan ARIMA secara terperinci, membahas komponen-komponennya, dan menunjukkan bagaimana ARIMA dapat diterapkan pada prediksi lalu lintas.

Apa itu ARIMA?

ARIMA merupakan kombinasi dari tiga komponen utama:

AutoRegressive (AR):

Menangkap hubungan antara pengamatan dan sejumlah pengamatan yang tertinggal (nilai masa lalu).

Parameter "p" menentukan jumlah istilah yang tertinggal yang akan disertakan.

Integrated(I):

Mengacu pada pembedaan data untuk membuatnya stasioner (misalnya, menghilangkan tren dan musim).

Parameter "d" menentukan berapa kali data dibedakan.

Moving Average (MA):

Menggunakan ketergantungan antara pengamatan dan kesalahan residual dari model rata-rata bergerak yang diterapkan pada pengamatan yang tertunda.

Parameter "q" menentukan ukuran jendela rata-rata bergerak.

Model ARIMA dilambangkan sebagai ARIMA(p, d, q) , di mana:

p : Jumlah suku autoregresif.

d : Derajat perbedaan.

q : Jumlah suku rata-rata bergerak.

Mengapa Menggunakan ARIMA untuk Prediksi Lalu Lintas?

ARIMA sangat cocok untuk prediksi lalu lintas karena:

• Peramalan Univariat: Bekerja langsung dengan data lalu lintas historis (misalnya, jumlah kendaraan dari waktu ke waktu) tanpa memerlukan fitur tambahan.
• Penanganan Tren dan Musiman: Pola lalu lintas sering kali menunjukkan siklus harian, mingguan, atau musiman. ARIMA dapat menangkap tren berulang ini.
• Interpretabilitas: Tidak seperti model pembelajaran mendalam, ARIMA memberikan hasil yang dapat diinterpretasikan, sehingga lebih mudah untuk memahami pola yang mendasarinya.
• Kesederhanaan: ARIMA relatif mudah diimplementasikan dan memerlukan sumber daya komputasi minimal dibandingkan dengan model pembelajaran mesin. 

Namun, ARIMA memiliki keterbatasan:

• Bermasalah dengan input multivariat (misalnya, menggabungkan data cuaca atau kejadian dengan data lalu lintas).
• Mungkin tidak berfungsi dengan baik untuk pola lalu lintas yang sangat kompleks atau non-linier.

Langkah-langkah untuk Menerapkan ARIMA untuk Prediksi Lalu Lintas

Langkah 1: Pengumpulan Data

Kumpulkan data lalu lintas historis (misalnya, jumlah kendaraan, kecepatan, atau tingkat kemacetan) secara berkala (misalnya, setiap 5, 15, atau 60 menit).

Pastikan data bersih (tidak ada nilai yang hilang atau outlier).

Langkah 2: Visualisasikan Data

Buat plot data deret waktu untuk mengidentifikasi tren, musim, dan gangguan.

Contoh koding:

import matplotlib.pyplot as plt
plt.plot(traffic_data)
plt.title("Traffic Counts Over Time")
plt.show()

Langkah 3: Periksa apakah data Stasioner

ARIMA mengasumsikan bahwa deret waktu bersifat stasioner (nilai rata-rata, varians, dan autokorelasi konstan dari waktu ke waktu).

Gunakan uji statistik seperti uji Augmented Dickey-Fuller (ADF) untuk memeriksa stasioneritas:

Contoh koding:

from statsmodels.tsa.stattools import adfuller
result = adfuller(traffic_data)
print(f"ADF Statistic: {result[0]}, p-value: {result[1]}")

Jika data tidak stasioner, terapkan differencing (d > 0) untuk membuatnya stasioner.

Langkah 4: Tentukan Parameter ARIMA (p, d, q)

Gunakan alat seperti plot Autocorrelation Function (ACF) dan Partial Autocorrelation Function (PACF) untuk memperkirakan p dan q:

Contoh koding:

from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
plot_acf(traffic_data)
plot_pacf(traffic_data)
plt.show()

Plot ACF membantu menentukan q (lag yang melampaui batas korelasi), dan plot PACF membantu menentukan p.

Langkah 5: Melatih Model ARIMA

Sesuaikan model ARIMA menggunakan parameter yang diidentifikasi:

Contoh koding:

from statsmodels.tsa.arima.model import ARIMA
model = ARIMA(traffic_data, order=(p, d, q))
model_fit = model.fit()
print(model_fit.summary())

Langkah 6: Buat Prediksi

Gunakan model yang telah dilatih untuk memperkirakan nilai lalu lintas di masa mendatang:

Contoh koding:

forecast = model_fit.forecast(steps=10)  # Predict next 10 time steps
print(forecast)

Langkah 7: Mengevaluasi Model

Bandingkan nilai prediksi dengan data aktual menggunakan metrik seperti:

Mean Absolute Error (MAE):

from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(actual_values, predicted_values)
print(f"MAE: {mae}")

Root Mean Square Error (RSME):

from sklearn.metrics import mean_squared_error
rmse = mean_squared_error(actual_values, predicted_values, squared=False)
print(f"RMSE: {rmse}")

Contoh yang saya gunakan adalah data lalu lintas harian di kota bandung yang saya dapatkan di : https://satudata.bandungkab.go.id/dataset/data-lalu-lintas-masuk , dan kemudian saya jalankan dengan google colab. Unduh datanya dalam bentuk CSV dan kemudian satu persatu kita olah.

1. Pengolahan data awal

#Load and Preprocess the Data
import pandas as pd
# Load the dataset, skipping the first two rows (headers)
data = pd.read_csv('data_bandung.csv', header=None, skiprows=2, names=['Wilayah', 'Year', 'Month', 'Day', 'Golongan', 'Jumlah'])
# Display the first few rows to verify
print(data.head())
# Filter the data for 'Golongan' equal to "I"
filtered_data = data[data['Golongan'] == "II"]
# Create a datetime column for time-series analysis
#filtered_data['Date'] = pd.to_datetime(filtered_data[['Year', 'Month', 'Day']])
filtered_data = filtered_data.assign(Date=pd.to_datetime(filtered_data[['Year', 'Month', 'Day']]))
# Sort the data by date
data = filtered_data.sort_values(by='Date').reset_index(drop=True)
# Display the cleaned data
print(data.head())

Hasilnya seperti ini :

             Wilayah  Year  Month  Day Golongan  Jumlah
0  Kabupaten Bandung  2020      1    2        I   35576
1  Kabupaten Bandung  2020      1    3        I   36028
2  Kabupaten Bandung  2020      1    4        I   37828
3  Kabupaten Bandung  2020      1    5        I   33637
4  Kabupaten Bandung  2020      1    6        I   33657
             Wilayah  Year  Month  Day Golongan  Jumlah       Date
0  Kabupaten Bandung  2020      1    1       II     340 2020-01-01
1  Kabupaten Bandung  2020      1    2       II    1149 2020-01-02
2  Kabupaten Bandung  2020      1    3       II    1649 2020-01-03
3  Kabupaten Bandung  2020      1    4       II    1483 2020-01-04
4  Kabupaten Bandung  2020      1    5       II     893 2020-01-05

2. Visualisasi Data

# Visualize the Data
import matplotlib.pyplot as plt
# Plot the time series
plt.figure(figsize=(12, 6))
plt.plot(data['Date'], data['Jumlah'], label='Traffic Data')
plt.title('Traffic Data Over Time')
plt.xlabel('Date')
plt.ylabel('Jumlah')
plt.legend()
plt.show()

Hasil visualisasinya seperti ini :

2. Cek apakah data statisioner : 

#Check for Stationarity
from statsmodels.tsa.stattools import adfuller
# Perform ADF test
result = adfuller(data['Jumlah'])
print(f"ADF Statistic: {result[0]}")
print(f"p-value: {result[1]}")
# Interpretation
if result[1] <= 0.05:
    print("The data is stationary.")
else:
    print("The data is non-stationary. Differencing may be required.")

Hasilnya ini :

ADF Statistic: -4.2035830664815785
p-value: 0.0006497583886865874
The data is stationary.

4. Jika tidak statisioner lakukan ini :

#if non stationary
data['Value_Diff'] = data['Jumlah'].diff().dropna()
# Plot the differenced data
plt.figure(figsize=(12, 6))
plt.plot(data['Date'][1:], data['Value_Diff'], label='Differenced Data')
plt.title('Differenced Traffic Data')
plt.xlabel('Date')
plt.ylabel('Differenced Value')
plt.legend()
plt.show()

5. Buat pemodelan ARIMA dengan library python pmdarima

Jangan lupa jika menggunakan google colab install dulu librarynya: 

#Build the ARIMA Model
!pip install pmdarima

Lanjut ini : 

from pmdarima import auto_arima
# Fit the auto_arima model to find optimal parameters
model = auto_arima(data['Jumlah'], seasonal=True, m=12, trace=True, error_action='ignore', suppress_warnings=True)
print(model.summary())

Lalu Training model arima nya:

#train the arima model
from statsmodels.tsa.arima.model import ARIMA
# Extract optimal parameters from auto_arima
order = model.order
# Train the ARIMA model
arima_model = ARIMA(data['Jumlah'], order=order)
arima_fit = arima_model.fit()
# Print model summary
print(arima_fit.summary())

Hasilnya training seperti ini :

ARIMAX Results                                
==============================================================================
Dep. Variable:                 Jumlah   No. Observations:                 1813
Model:                 ARIMA(0, 1, 2)   Log Likelihood              -14093.174
Date:                Sun, 16 Mar 2025   AIC                          28192.348
Time:                        03:48:09   BIC                          28208.854
Sample:                             0   HQIC                         28198.439
                               - 1813                                         
Covariance Type:                  opg                                         
==============================================================================
                 coef    std err          z      P>|z|      [0.025      0.975]
------------------------------------------------------------------------------
ma.L1         -0.7766      0.020    -39.006      0.000      -0.816      -0.738
ma.L2         -0.1608      0.020     -7.989      0.000      -0.200      -0.121
sigma2      3.331e+05   1.03e+04     32.290      0.000    3.13e+05    3.53e+05
===================================================================================
Ljung-Box (L1) (Q):                   0.00   Jarque-Bera (JB):               332.12
Prob(Q):                              0.98   Prob(JB):                         0.00
Heteroskedasticity (H):               1.69   Skew:                            -1.02
Prob(H) (two-sided):                  0.00   Kurtosis:                         3.45
===================================================================================

Warnings:
[1] Covariance matrix calculated using the outer product of gradients (complex-step).

6. Lanjut ke prediksi 1 tahun / 365 hari kedepan menggunakan arima :

# Forecast for the next 365 days (or desired horizon)
forecast_steps = 365
forecast = arima_fit.forecast(steps=forecast_steps)
# Create a date range for the forecast period
forecast_dates = pd.date_range(start='2025-01-01', periods=forecast_steps, freq='D')
# Combine forecast dates and values into a DataFrame
forecast_data = pd.DataFrame({'Date': forecast_dates, 'Forecasted_Value': forecast})
# Display the forecasted data
print(forecast_data.head())
# Plot the forecast
plt.figure(figsize=(12, 6))
plt.plot(data['Date'], data['Jumlah'], label='Historical Data')
plt.plot(forecast_data['Date'], forecast_data['Forecasted_Value'], label='Forecasted Data', color='red')
plt.title('Traffic Data Forecast for 2025')
plt.xlabel('Date')
plt.ylabel('Value')
plt.legend()
plt.show()

Hasilnya seperti ini dan grafiknya seperti gambar paling atas tulisan ini : 

           Date  Forecasted_Value
1813 2025-01-01       1791.804722
1814 2025-01-02       1798.622821
1815 2025-01-03       1798.622821
1816 2025-01-04       1798.622821
1817 2025-01-05       1798.622821

Keunggulan ARIMA

• Dapat ditafsirkan: Mudah dipahami dan dijelaskan kepada pemangku kepentingan.
• Efisien: Memerlukan daya komputasi yang lebih sedikit dibandingkan dengan model pembelajaran mendalam.
• Menangani Tren dan Musiman: Efektif untuk menangkap pola berulang dalam data lalu lintas.

Keterbatasan ARIMA

• Fokus Univariat: Tidak dapat menggabungkan faktor eksternal seperti cuaca, peristiwa, atau kondisi jalan.
• Persyaratan Stasioneritas: Data non-stasioner harus ditransformasikan, yang mungkin akan mempersulit proses.
• Asumsi Linier: Kesulitan dengan pola lalu lintas yang sangat non-linier atau kacau.

Kapan Menggunakan ARIMA vs. Model Lain

Gunakan ARIMA Saat:

• Anda memiliki data lalu lintas univariat (misalnya, jumlah kendaraan dari waktu ke waktu).
• Data menunjukkan tren dan musim yang jelas.
• Anda memerlukan model yang sederhana dan dapat ditafsirkan.

Pertimbangkan Alternatif Saat:

• Anda ingin menggabungkan input multivariat (gunakan model LSTM atau pembelajaran mesin). Data tersebut sangat non-linier atau kompleks (gunakan model pembelajaran mendalam seperti LSTM atau GRU).
• Diperlukan prediksi waktu nyata (gunakan model hibrida atau pembelajaran penguatan).

Kesimpulan 

ARIMA adalah alat yang ampuh dan dapat ditafsirkan untuk prediksi lalu lintas, terutama saat menangani data deret waktu univariat. Dengan memahami komponennya dan mengikuti pendekatan terstruktur, Anda dapat menggunakan ARIMA secara efektif untuk memperkirakan pola lalu lintas. Namun, untuk skenario yang lebih kompleks yang melibatkan beberapa variabel atau prediksi waktu nyata, pertimbangkan untuk menggabungkan ARIMA dengan model lain atau beralih ke teknik lanjutan seperti LSTM ( dibahas pada tulisan selanjutnya ).

- Powered by Qwen AI -

Read More