tomi_hartanto_TIFNJK_E41221088/README.md

521 lines
19 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# 🍄 Sistem Pakar Diagnosis Jamur Tiram
Aplikasi **sistem pakar berbasis web** untuk mendiagnosis penyakit pada **jamur tiram** (*Pleurotus ostreatus*) menggunakan metode **Forward Chaining**, **Decision Tree**, dan **Certainty Factor**.
Dibangun dengan Laravel 12, Tailwind CSS 4, dan MySQL/SQLite.
---
## 📋 Daftar Isi
- [Fitur](#fitur)
- [Tech Stack](#tech-stack)
- [Struktur Database](#struktur-database)
- [Metode Sistem Pakar](#metode-sistem-pakar)
- [Forward Chaining](#1-forward-chaining)
- [Decision Tree](#2-decision-tree)
- [Certainty Factor](#3-certainty-factor)
- [Alur Diagnosis](#alur-diagnosis)
- [API Endpoints](#api-endpoints)
- [Instalasi](#instalasi)
- [Seeder Data](#seeder-data)
---
## ✨ Fitur
| Fitur | Keterangan |
|---|---|
| **Diagnosis Gejala** | Pilih gejala yang tampak pada jamur tiram melalui form interaktif |
| **Forward Chaining** | Mencocokkan gejala dengan rule-based knowledge base |
| **Decision Tree Traversal** | Menelusuri pohon keputusan untuk mendapatkan reasoning path |
| **Certainty Factor** | Menghitung tingkat keyakinan diagnosis (0–100%) |
| **Riwayat Diagnosis** | Menyimpan riwayat ke database + LocalStorage (ID-only) |
| **Detail Hasil** | Menampilkan deskripsi penyakit, solusi penanganan, bahan, dan alat |
| **Manajemen Riwayat** | Lihat detail dan hapus riwayat dari LocalStorage |
| **Halaman Informasi Penyakit** | Galeri 10 penyakit jamur tiram dengan gambar dan deskripsi |
---
## 🛠 Tech Stack
| Layer | Teknologi |
|---|---|
| **Backend** | PHP 8.2+, Laravel 12 |
| **Frontend** | Blade Template, Tailwind CSS 4 (CDN), Vanilla JS |
| **Database** | MySQL (production) / SQLite (development) |
| **Build Tool** | Vite 7, Laravel Vite Plugin |
| **Dev Tools** | Concurrently, Pail (log), Pint (linting), PHPUnit |
> **Catatan:** Frontend murni menggunakan **Blade + Tailwind CDN** tanpa framework JS seperti Vue atau React. Integritas dan validasi CLI biasa digunakan.
---
## 🗄 Struktur Database
### Entity Relationship
```
gejala ──┬──< penyakit_gejala >──┬── penyakit
│ │
└── (digunakan oleh) ────┘
┌─────────────────────┐
diagnosis_history ───────>─────────────┤ hasil_penyakit_id │
└─────────────────────┘
```
### Tabel `gejala`
Menyimpan 24 gejala (G01–G25) yang mungkin tampak pada jamur tiram.
| Kolom | Tipe | Keterangan |
|---|---|---|
| `id` | bigint (PK) | Auto increment |
| `kode` | varchar (unique) | Kode gejala (G01–G25) |
| `nama` | varchar | Nama gejala |
| `deskripsi` | text (nullable) | Penjelasan gejala |
| `kategori` | varchar (nullable) | Kelompok gejala (Warna, Pertumbuhan, Kerusakan, dll.) |
| `timestamps` | - | created_at, updated_at |
**Contoh data:**
| Kode | Nama | Kategori |
|---|---|---|
| G01 | Jamur tiram terlihat membusuk | Warna & Kondisi |
| G06 | Pertumbuhan jamur tiram lambat | Pertumbuhan |
| G11 | Pada media baglog terdapat noda warna hitam | Kondisi Baglog |
| G22 | Perubahan tekstur jamur lembek | Tekstur |
### Tabel `penyakit`
Menyimpan 10 penyakit/hama (P01–P10) yang menyerang jamur tiram.
| Kolom | Tipe | Keterangan |
|---|---|---|
| `id` | bigint (PK) | Auto increment |
| `kode` | varchar (unique) | Kode penyakit (P01–P10) |
| `nama` | varchar | Nama penyakit |
| `tipe` | varchar | Jenis: Jamur, Bakteri, Hama Binatang, Hama Serangga |
| `deskripsi` | text | Penjelasan penyakit |
| `solusi` | json (nullable) | Array langkah penanganan |
| `bahan` | json (nullable) | Array bahan/kimia yang dibutuhkan |
| `alat` | json (nullable) | Array alat yang dibutuhkan |
| `image_url` | varchar (nullable) | URL gambar penyakit |
| `timestamps` | - | created_at, updated_at |
**Daftar penyakit:**
| Kode | Nama | Tipe |
|---|---|---|
| P01 | Trichoderma spp (Jamur Hijau) | Jamur |
| P02 | Neurospora spp | Jamur |
| P03 | Mucor spp | Jamur |
| P04 | Penicilium spp | Jamur |
| P05 | Pseudomonas tolaasii (Brown Blotch) | Bakteri |
| P06 | Chaetomium spp | Jamur |
| P07 | Coprinus spp (Jamur Liar) | Jamur |
| P08 | Tikus | Hama Binatang |
| P09 | Lalat | Hama Serangga |
| P10 | Tunggu/Gurem (Acari) | Hama Serangga |
### Tabel `penyakit_gejala` (Pivot)
Menghubungkan penyakit dengan gejala beserta **bobot CF Pakar** (Certainty Factor dari pakar).
| Kolom | Tipe | Keterangan |
|---|---|---|
| `id` | bigint (PK) | Auto increment |
| `penyakit_id` | bigint (FK) | → penyakit.id |
| `gejala_id` | bigint (FK) | → gejala.id |
| `cf_pakar` | decimal(3,2) | Bobot keyakinan pakar (0.1–1.0) |
| `deskripsi` | text (nullable) | Keterangan relasi |
| `timestamps` | - | created_at, updated_at |
| *unique* | - | (penyakit_id, gejala_id) |
**Contoh data P01 (Trichoderma):**
| Gejala | CF Pakar |
|---|---|
| G12 – Bintik noda hijau | 1.0 |
| G18 – Noda hijau di daun jamur | 0.8 |
| G06 – Pertumbuhan lambat | 0.6 |
| G07 – Tidak tumbuh | 0.8 |
### Tabel `diagnosis_history`
Menyimpan riwayat diagnosis yang dilakukan pengguna.
| Kolom | Tipe | Keterangan |
|---|---|---|
| `id` | bigint (PK) | Auto increment |
| `gejala_terpilih` | json | Array ID gejala yang dipilih |
| `hasil_penyakit_id` | bigint (FK) | → penyakit.id (hasil diagnosis) |
| `confidence_level` | float | Tingkat keyakinan (0–100) |
| `timestamps` | - | created_at, updated_at |
---
## 🧠 Metode Sistem Pakar
### 1. Forward Chaining
**Forward Chaining** adalah metode penalaran berbasis aturan (*rule-based reasoning*) yang dimulai dari fakta (gejala) menuju kesimpulan (penyakit).
#### Cara Kerja (Saat Ini)
Rules didefinisikan secara hardcoded di `app/Services/ForwardChainingService.php`:
```php
// Format: [id, penyakit_id, kode, gejala_ids]
$rules = [
['id' => 1, 'penyakit_id' => 1, 'kode' => 'R1', 'gejala_ids' => [11, 17, 5, 6]], // P01 - Trichoderma
['id' => 2, 'penyakit_id' => 2, 'kode' => 'R2', 'gejala_ids' => [12, 5, 6]], // P02 - Neurospora
['id' => 3, 'penyakit_id' => 3, 'kode' => 'R3', 'gejala_ids' => [10, 5, 6]], // P03 - Mucor
['id' => 4, 'penyakit_id' => 4, 'kode' => 'R4', 'gejala_ids' => [11, 22, 5]], // P04 - Penicilium
['id' => 5, 'penyakit_id' => 5, 'kode' => 'R5', 'gejala_ids' => [1, 9, 13, 21]], // P05 - Pseudomonas
['id' => 6, 'penyakit_id' => 6, 'kode' => 'R6', 'gejala_ids' => [22, 5, 8]], // P06 - Chaetomium
['id' => 7, 'penyakit_id' => 7, 'kode' => 'R7', 'gejala_ids' => [14, 23, 19]], // P07 - Coprinus
['id' => 8, 'penyakit_id' => 8, 'kode' => 'R8', 'gejala_ids' => [8, 23, 19]], // P08 - Tikus
['id' => 9, 'penyakit_id' => 9, 'kode' => 'R9', 'gejala_ids' => [1, 2, 24]], // P09 - Lalat
['id' => 10, 'penyakit_id' => 10, 'kode' => 'R10','gejala_ids' => [4, 18, 24]], // P10 - Tunggu/Gurem
];
```
**Algoritma `findMatchingDiseases()`:**
1. **Exact match** — Iterasi semua rule; jika **semua** gejala dalam rule cocok dengan gejala yang dipilih user, penyakit rule tersebut dianggap match.
2. **Fallback partial match** — Jika tidak ada satu pun rule yang match persis, sistem mengambil **semua penyakit** yang memiliki **setidaknya satu gejala** yang dipilih user. Certainty Factor kemudian menghitung probabilitasnya.
3. Hasil dikembalikan sebagai array model `Penyakit` untuk diproses lebih lanjut.
#### Hubungan Rule dengan Relasi CF
| Rule | Penyakit | Gejala dalam Rule | Gejala di Pivot (CF) |
|---|---|---|---|
| R1 | P01 | G12, G18, G06, G07 | G12(1.0), G18(0.8), G06(0.6), G07(0.8) |
| R2 | P02 | G13, G06, G07 | G13(1.0), G06(0.6), G07(0.8) |
| R3 | P03 | G11, G06, G07 | G11(1.0), G06(0.6), G07(0.8) |
| R4 | P04 | G12, G23, G06 | G12(1.0), G23(0.8), G06(0.6) |
| R5 | P05 | G01, G10, G14, G22 | G01(1.0), G10(0.8), G14(0.8), G22(0.8) |
| R6 | P06 | G23, G06, G09 | G23(1.0), G06(0.6), G09(0.6) |
| R7 | P07 | G15, G24, G20 | G15(1.0), G24(0.8), G20(0.6) |
| R8 | P08 | G09, G24, G20 | G09(1.0), G24(0.8), G20(0.6) |
| R9 | P09 | G01, G02, G25 | G01(1.0), G02(0.8), G25(0.8) |
| R10 | P10 | G05, G19, G25 | G05(1.0), G19(0.8), G25(0.8) |
---
### 2. Decision Tree
**Decision Tree** digunakan untuk menelusuri jalur diagnosis berdasarkan gejala utama (primary symptoms) secara hierarkis.
#### Struktur Pohon (Saat Ini)
Pohon keputusan didefinisikan secara hardcoded di `ForwardChainingService.php` dengan **2 level depth**:
```
root: Diagnosis Jamur Tiram
├── G11 (Tubuh Buah Pucat) ─────┬── G18 (Ada Lendir) → P01
│ └── G23 (Bau Menyengat) → P04
├── G12 (Umbi Membusuk) ─────────└── G06 (Substrat Basah) → P02
├── G10 (Kepala Susu Coklat) ────└── G06 (Substrat Basah) → P03
├── G01 (Jamur Putih/Kepala) ────┬── G10 (Busuk Pangkal) → P05
│ └── G02 (Berbau Asam) → P09
├── G23 (Bau Menyengat) ─────────└── G09 (Berlendir) → P06
├── G15 (Kepala Susu Kerdil) ────└── G24 (Warna Tidak Seragam) → P07
├── G09 (Berlendir) ─────────────└── G20 (Miselium Tidak) → P08
└── G05 (Pertumbuhan Terganggu) ─└── G19 (Kontaminan) → P10
```
#### Cara Kerja `traverseDecisionTree()`
1. Ambil semua branch level-1 dari `root.branches`.
2. Untuk setiap branch, cek apakah `symptom_id` branch ada dalam `selectedGejalaIds`.
3. Jika ya, catat branch sebagai `matched` dan telusuri `children` untuk menemukan penyakit yang mungkin.
4. Hasilnya adalah array path yang berisi: `symptom_id`, `name`, `matched`, dan `possible_penyakit_ids`.
Fungsi ini menghasilkan **reasoning path** yang ditampilkan di log/debug untuk transparansi diagnosis.
> 📖 **Lihat `dc.md`** untuk flowchart decision tree dan detail traversal.
---
### 3. Certainty Factor
**Certainty Factor (CF)** adalah metode untuk mengukur tingkat keyakinan terhadap suatu diagnosis berdasarkan kombinasi bobot pakar dan keyakinan pengguna.
#### Formula yang Digunakan
**Langkah 1 — CF untuk setiap gejala terpilih:**
```
CF[H, E] = CF[E] × CF[H, E]
```
Dimana:
- `CF[H, E]` = Certainty Factor hipotesis (penyakit) berdasarkan evidence (gejala)
- `CF[E]` = Certainty Factor dari pengguna (CF User) — dari select dropdown per gejala (0, 0.4, 0.6, **0.8** default, 1.0)
- `CF[H, E]` = Certainty Factor dari pakar (CF Pakar) — dari tabel `penyakit_gejala`
**Langkah 2 — Kombinasi multiple symptoms:**
```
CF_combine(CF1, CF2) = CF1 + CF2 × (1 - CF1)
```
Rumus ini diterapkan secara iteratif untuk semua gejala yang cocok pada satu penyakit.
#### Implementasi
**File:** `app/Services/CertaintyFactorService.php`
**Metode `calculateCFWithDetails()`:**
1. Ambil mapping CF Pakar dari `penyakit_gejala` untuk penyakit tertentu.
2. Filter hanya gejala yang ada di `selectedGejalaIds`.
3. Untuk setiap mapping, hitung `CF_he = cf_pakar × cf_user` (cf_user dari input select user, default 0.8).
4. Kombinasikan semua `CF_he` menggunakan formula CF combine.
5. Hasil akhir dikonversi ke persentase integer (0–100).
**Contoh Perhitungan (P01 — Trichoderma):**
User memilih gejala G12, G18, G06, dan G07:
| Gejala | CF Pakar | CF User | CF[H,E] |
|---|---|---|---|
| G12 | 1.0 | 0.8 | 0.80 |
| G18 | 0.8 | 0.8 | 0.64 |
| G06 | 0.6 | 0.8 | 0.48 |
| G07 | 0.8 | 0.8 | 0.64 |
Kombinasi:
- `CF1 = 0.80`
- `CF2 = 0.80 + 0.64 × (1 - 0.80) = 0.928`
- `CF3 = 0.928 + 0.48 × (1 - 0.928) = 0.96256`
- `CF4 = 0.96256 + 0.64 × (1 - 0.96256) = 0.9865216`
**Hasil:** `CF = 0.9865 → 98.65%`
#### Kategori Keyakinan
| CF Value | Status |
|---|---|
| ≥ 0.9 | Sangat Yakin |
| ≥ 0.8 | Yakin |
| ≥ 0.6 | Cukup Yakin |
| ≥ 0.4 | Sedikit Yakin |
| < 0.4 | Tidak Yakin |
---
## 🔄 Alur Diagnosis
```
User membuka /diagnosis
│
▼
Menampilkan form dengan 24 gejala (checkbox + select CF user per gejala, default 0.8 — hanya terkirim untuk gejala yang dicentang)
│
▼ (POST /diagnosis)
Validasi input (gejala_ids required, min 1)
│
▼
┌─────────────────────────────────────────────────────┐
│ 1. Forward Chaining — findMatchingDiseases() │
│ • Exact match dengan rule │
│ • Jika tidak ada → fallback partial match │
│ • Return array Penyakit model │
└─────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────┐
│ 2. Decision Tree — traverseDecisionTree() │
│ • Telusuri branch berdasarkan primary symptoms │
│ • Catat possible penyakit per branch │
│ • Return reasoning path array │
└─────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────┐
│ 3. Certainty Factor — calculateCFWithDetails() │
│ • Untuk setiap penyakit yang match │
│ • Hitung CF per gejala → combine │
│ • Return cf_value, cf_percentage, status │
└─────────────────────────────────────────────────────┘
│
▼
Sortir hasil berdasarkan CF percentage (descending)
│
▼
┌─────────────────────────────────────────────────────┐
│ Hasil: │
│ • 0 penyakit → Tampilkan error "Tidak ada cocok" │
│ • >1 penyakit → Tampilkan error dengan daftar │
│ penyakit dan gejala yang kurang │
│ • 1 penyakit → Simpan history, tampilkan hasil │
│ (deskripsi, solusi, bahan, alat, │
│ confidence %) │
└─────────────────────────────────────────────────────┘
```
---
## 🌐 API Endpoints
### Web Routes
| Method | URI | Controller Method | Keterangan |
|---|---|---|---|
| GET | `/` | Closure | Halaman beranda |
| GET | `/diagnosis` | `DiagnosisController@showForm` | Form gejala |
| POST | `/diagnosis` | `DiagnosisController@process` | Proses diagnosis |
| GET | `/riwayat` | `DiagnosisController@showHistory` | Riwayat diagnosis |
| GET | `/riwayat/{id}` | `DiagnosisController@detailHistory` | Detail riwayat |
| GET | `/penyakit` | Closure | Info penyakit |
| GET | `/tentang` | Closure | Halaman tentang |
### API Routes
| Method | URI | Controller Method | Request | Response |
|---|---|---|---|---|
| POST | `/api/diagnosis` | `DiagnosisController@apiProcess` | `{gejala_ids: [], cf_user: {}}` | JSON diagnosis |
| POST | `/api/history-data` | `DiagnosisController@getHistoryData` | `{ids: [1,2,3]}` | JSON array histories with penyakit relation |
#### Response `/api/history-data`
```json
[
{
"id": 1,
"gejala_terpilih": [1, 5, 6],
"hasil_penyakit_id": 1,
"confidence_level": 93.0,
"created_at": "2026-07-03T12:00:00Z",
"updated_at": "2026-07-03T12:00:00Z",
"penyakit": {
"id": 1,
"kode": "P01",
"nama": "Trichoderma spp (Jamur Hijau)",
"deskripsi": "...",
"solusi": ["Pisahkan baglog...", "Gunakan fungisida..."],
"bahan": ["Karbendazim 50 WP", "..."],
"alat": ["Drum sterilisasi", "..."]
}
}
]
```
---
## 📦 Instalasi
### Prasyarat
- PHP 8.2+
- Composer
- Node.js & npm
- Database (MySQL atau SQLite)
### Langkah Instalasi
```bash
# 1. Clone repositori
git clone <repository-url>
cd jamur
# 2. Install dependency PHP
composer install
# 3. Install dependency frontend
npm install
# 4. Copy environment
cp .env.example .env
# 5. Generate app key
php artisan key:generate
# 6. Konfigurasi database di .env
# Untuk SQLite (default development):
# DB_CONNECTION=sqlite
# (cukup buat file database/database.sqlite)
#
# Untuk MySQL:
# DB_CONNECTION=mysql
# DB_HOST=127.0.0.1
# DB_PORT=3306
# DB_DATABASE=jamur
# DB_USERNAME=root
# DB_PASSWORD=
# 7. Jalankan migrasi + seeder
php artisan migrate --seed
# 8. Build frontend
npm run build
# 9. Jalankan development server
php artisan serve
# Frontend development (opsional):
# npm run dev
```
### Perintah Development
```bash
# Jalankan semua service (server, queue, log, vite) sekaligus
composer run dev
# Jalankan test
composer run test
```
---
## 🌱 Seeder Data
Seeder sudah menyediakan data lengkap:
| Seeder | Data |
|---|---|
| `GejalaSeeder` | 24 gejala (G01–G25) |
| `PenyakitSeeder` | 10 penyakit (P01–P10) dengan deskripsi, solusi, bahan, dan alat |
| `PenyakitGejalaSeeder` | Relasi penyakit-gejala dengan CF Pakar sesuai tabel bobot |
## 📁 Struktur Direktori (Aplikasi)
```
app/
├── Http/Controllers/
│ └── DiagnosisController.php # Menangani request diagnosis, riwayat
├── Models/
│ ├── Penyakit.php # Model penyakit dengan relasi
│ ├── Gejala.php # Model gejala dengan relasi
│ ├── PenyakitGejala.php # Model pivot CF
│ └── DiagnosisHistory.php # Model riwayat diagnosis
└── Services/
├── DiagnosisService.php # Orchestrator: FC → DT → CF
├── ForwardChainingService.php # Rule-based reasoning + decision tree
└── CertaintyFactorService.php # CF calculation engine
database/
├── migrations/ # 7 file migrasi
└── seeders/ # 4 file seeder
resources/views/
├── layouts/
│ ├── app.blade.php # Layout utama (navbar + main)
│ ├── home.blade.php # Halaman beranda
│ ├── penyakit.blade.php # Galeri penyakit
│ └── tentang.blade.php # Halaman tentang
└── diagnosis/
├── form.blade.php # Form pilih gejala
├── hasil.blade.php # Hasil diagnosis
└── history.blade.php # Riwayat diagnosis
```
---
## 👨‍💻 Pengembang
**Tomi Hartanto** — Sistem Pakar Jamur Tiram
&copy; 2025–2026 — Semua Hak Dilindungi.