Upload 13 files

api.py

@@ -0,0 +1,391 @@
+import os
+import io
+import base64
+import shutil
+import datetime
+
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from fastapi import APIRouter, UploadFile, File, HTTPException, Form
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from fpdf import FPDF
+
+from src.config import CLASSES, OUTPUT_DIR, CHECKPOINT_DIR, download_model_from_hf
+from src.preprocess import val_transforms, precheck_transforms
+from src.models.precheck_model import BrainPreCheckModel
+from src.models.classifier_model import BrainHybridModel
+from src.gemini_client import generate_radiology_report
+from src.explainability import generate_attention_heatmap
+from src.database import upsert_patient, get_patient, add_scan_record, get_patient_history
+
+router = APIRouter()
+
+# ─────────────────────────────────────────────────────────────
+# Util tanggal Indonesia (dipakai di laporan PDF)
+# ─────────────────────────────────────────────────────────────
+_HARI_ID = ["Senin", "Selasa", "Rabu", "Kamis", "Jumat", "Sabtu", "Minggu"]
+_BULAN_ID = ["", "Januari", "Februari", "Maret", "April", "Mei", "Juni",
+             "Juli", "Agustus", "September", "Oktober", "November", "Desember"]
+
+
+def tanggal_indonesia_sekarang() -> str:
+    """Format tanggal sekarang, misal: 'Selasa, 7 Juli 2026' — bukan tanggal tetap."""
+    now = datetime.datetime.now()
+    return f"{_HARI_ID[now.weekday()]}, {now.day} {_BULAN_ID[now.month]} {now.year}"
+
+
+# ─────────────────────────────────────────────────────────────
+# Muat model-model AI secara global, SEKALI, saat modul ini diimpor
+# (yaitu saat app.py memanggil `from src.api import router`)
+# ─────────────────────────────────────────────────────────────
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+precheck_model = None
+hybrid_model = None
+
+try:
+    print("Memuat model Precheck...")
+    precheck_model = BrainPreCheckModel().to(device)
+    precheck_checkpoint = download_model_from_hf("best_precheck_model.pth") or os.path.join(CHECKPOINT_DIR, "best_precheck_model.pth")
+    if os.path.exists(precheck_checkpoint):
+        try:
+            precheck_model.load_state_dict(torch.load(precheck_checkpoint, map_location=device))
+            print(f"Sukses memuat bobot model Precheck dari {precheck_checkpoint}")
+        except RuntimeError:
+            print("Warning: Checkpoint precheck tidak kompatibel dengan arsitektur EfficientNet-B0 baru, menggunakan bobot pretrained bawaan.")
+    else:
+        print("Warning: best_precheck_model.pth tidak ditemukan, menggunakan bobot pretrained bawaan.")
+    precheck_model.eval()
+
+    print("Memuat model Utama Hybrid...")
+    hybrid_model = BrainHybridModel().to(device)
+    hybrid_checkpoint = download_model_from_hf("hybrid_vit_efficientnet_brain_best.pth") or os.path.join(CHECKPOINT_DIR, "best_hybrid_model.pth")
+    if os.path.exists(hybrid_checkpoint):
+        try:
+            ckpt = torch.load(hybrid_checkpoint, map_location=device)
+            if isinstance(ckpt, dict) and "model_state_dict" in ckpt:
+                hybrid_model.load_state_dict(ckpt["model_state_dict"])
+            else:
+                hybrid_model.load_state_dict(ckpt)
+            print(f"💾 Sukses memuat bobot model Classifier utama dari {hybrid_checkpoint}")
+        except RuntimeError as e:
+            print(f"Warning: Checkpoint classifier tidak kompatibel dengan arsitektur baru: {str(e)}. Menggunakan bobot pretrained bawaan.")
+    else:
+        print("Warning: best_hybrid_model.pth tidak ditemukan, menggunakan bobot pretrained bawaan.")
+    hybrid_model.eval()
+    print("✨ Seluruh model AI berhasil dimuat.")
+except Exception as e:
+    print(f"Gagal memuat model AI: {str(e)}")
+
+
+# ─────────────────────────────────────────────────────────────
+# Pydantic models
+# ─────────────────────────────────────────────────────────────
+class PatientCreate(BaseModel):
+    nik: str
+    name: str
+    age: int = None
+    birth_date: str = None
+    gender: str = None
+    address: str = None
+    phone: str = None
+
+
+class PDFDownloadRequest(BaseModel):
+    patient_name: str
+    patient_age: str
+    patient_gender: str
+    patient_nik: str
+    patient_birth_date: str = ""
+    patient_address: str = ""
+    patient_phone: str = ""
+    report_text: str
+
+
+# ─────────────────────────────────────────────────────────────
+# Endpoint: status server
+# ─────────────────────────────────────────────────────────────
+@router.get("/api/status")
+def get_status():
+    """Mengecek status online server dan ketersediaan model AI"""
+    return {
+        "status": "Online",
+        "precheck_model_loaded": precheck_model is not None,
+        "classifier_model_loaded": hybrid_model is not None,
+        "device": str(device),
+    }
+
+
+# ─────────────────────────────────────────────────────────────
+# Endpoint: data pasien
+# ─────────────────────────────────────────────────────────────
+@router.post("/api/patients/")
+def register_patient(patient: PatientCreate):
+    """Menyimpan atau memperbarui data profil pasien"""
+    try:
+        upsert_patient(
+            nik=patient.nik,
+            name=patient.name,
+            age=patient.age,
+            birth_date=patient.birth_date,
+            gender=patient.gender,
+            address=patient.address,
+            phone=patient.phone,
+        )
+        return {"status": "Success", "message": "Data pasien berhasil disimpan."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Gagal menyimpan data pasien: {str(e)}")
+
+
+@router.get("/api/patients/{nik}")
+def get_patient_info(nik: str):
+    """Mengambil data pasien berdasarkan NIK"""
+    patient = get_patient(nik)
+    if not patient:
+        raise HTTPException(status_code=404, detail="Pasien tidak ditemukan.")
+    return {"status": "Success", "patient": patient}
+
+
+@router.get("/api/patients/{nik}/history")
+def get_patient_scans_history(nik: str):
+    """Mengambil riwayat scan pasien berdasarkan NIK"""
+    try:
+        history = get_patient_history(nik)
+        return {"status": "Success", "history": history}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Gagal mengambil riwayat scan: {str(e)}")
+
+
+# ─────────────────────────────────────────────────────────────
+# Endpoint utama: analisis gambar scan otak
+# ─────────────────────────────────────────────────────────────
+@router.post("/api/analyze/")
+async def analyze_brain_image(file: UploadFile = File(...), patient_nik: str = Form(None)):
+    """
+    Endpoint utama untuk mengunggah gambar scan otak, menjalankan pre-check,
+    menjalankan klasifikasi penyakit, memvisualisasikan atensi model (XAI),
+    dan menghasilkan laporan radiologi AI.
+    """
+    # 1. Validasi Ekstensi File
+    if not file.filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+        raise HTTPException(status_code=400, detail="Format file harus berupa gambar (PNG, JPG, JPEG).")
+
+    try:
+        # 2. Simpan file unggahan sementara untuk visualisasi heatmap
+        temp_file_path = os.path.join("temp_uploads", file.filename)
+        with open(temp_file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # 3. Baca gambar untuk pemrosesan tensor PyTorch
+        image = Image.open(temp_file_path).convert("RGB")
+        # Dua tensor terpisah: precheck pakai normalisasi [0.5,0.5,0.5]
+        # (sesuai cara dia dilatih), hybrid pakai normalisasi ImageNet
+        # (sesuai cara model utama dilatih di notebook)
+        precheck_tensor = precheck_transforms(image).unsqueeze(0).to(device)
+        tensor_image = val_transforms(image).unsqueeze(0).to(device)
+
+        # 4. TAHAP 1: Precheck (Menyaring Gambar Valid Brain Scan vs Gambar Noise/Invalid)
+        is_valid = True
+        precheck_prob_val = 0.99
+        if precheck_model is not None:
+            with torch.no_grad():
+                precheck_outputs = precheck_model(precheck_tensor)
+                precheck_prob = F.softmax(precheck_outputs, dim=1)
+                is_valid_idx = torch.argmax(precheck_prob, dim=1).item()
+                precheck_prob_val = precheck_prob[0][is_valid_idx].item()
+                # Indeks 1: Valid, Indeks 0: Invalid (Sesuai dengan dataset latihan precheck)
+                is_valid = (is_valid_idx == 1)
+
+        # Jika gambar dinyatakan invalid, hentikan proses analisis awal
+        if not is_valid:
+            if os.path.exists(temp_file_path):
+                os.remove(temp_file_path)
+            return {
+                "status": "Invalid",
+                "filename": file.filename,
+                "message": "Gambar tidak dikenali sebagai scan otak yang valid (CT-Scan/MRI). Hubungi Administrator.",
+                "precheck_confidence": f"{precheck_prob_val * 100:.2f}%",
+            }
+
+        # 5. TAHAP 2: Klasifikasi Utama (5 Kelas Penyakit Otak)
+        if hybrid_model is None:
+            raise HTTPException(status_code=500, detail="Model utama klasifikasi tidak termuat di server.")
+
+        with torch.no_grad():
+            hybrid_outputs = hybrid_model(tensor_image)
+            hybrid_prob = F.softmax(hybrid_outputs, dim=1)
+            confidence, predicted_idx = torch.max(hybrid_prob, dim=1)
+
+            confidence_score = confidence.item() * 100
+            predicted_class = CLASSES[predicted_idx.item()]
+
+        # 6. TAHAP 3: Eksplanabilitas AI (XAI) - Hasilkan Peta Atensi Heatmap
+        heatmap_filename = f"heatmap_{os.path.splitext(file.filename)[0]}.png"
+        generate_attention_heatmap(temp_file_path, save_name=heatmap_filename)
+
+        # 7. TAHAP 4: Kirim Hasil Ke Gemini / Laporan Lokal
+        modality = "CT" if "ct" in file.filename.lower() else "MRI"
+        report_text = generate_radiology_report(predicted_idx.item(), confidence_score, modality)
+
+        # 8. Encode gambar visualisasi heatmap dan gambar asli menjadi base64 untuk dikirim langsung ke frontend
+        heatmap_path = os.path.join(OUTPUT_DIR, "figures", heatmap_filename)
+
+        with open(heatmap_path, "rb") as img_file:
+            heatmap_base64 = base64.b64encode(img_file.read()).decode('utf-8')
+
+        with open(temp_file_path, "rb") as img_file:
+            original_base64 = base64.b64encode(img_file.read()).decode('utf-8')
+
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+        # Simpan ke database jika patient_nik tersedia
+        if patient_nik:
+            try:
+                add_scan_record(
+                    patient_nik=patient_nik,
+                    filename=file.filename,
+                    modality=modality,
+                    predicted_class=predicted_class,
+                    confidence=confidence_score,
+                    report_text=report_text,
+                    original_b64=f"data:image/png;base64,{original_base64}",
+                    heatmap_b64=f"data:image/png;base64,{heatmap_base64}",
+                )
+            except Exception as db_err:
+                print(f" Gagal menyimpan riwayat scan ke database: {str(db_err)}")
+
+        # 9. Kembalikan respons akhir dalam format JSON
+        return {
+            "status": "Valid",
+            "filename": file.filename,
+            "modality_detected": modality,
+            "prediction": {
+                "class_name": predicted_class,
+                "class_index": predicted_idx.item(),
+                "confidence": f"{confidence_score:.2f}%",
+            },
+            "radiology_report": report_text,
+            "original_image_b64": f"data:image/png;base64,{original_base64}",
+            "heatmap_image_b64": f"data:image/png;base64,{heatmap_base64}",
+        }
+
+    except Exception as e:
+        if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+        raise HTTPException(status_code=500, detail=f"Terjadi kesalahan internal analisis: {str(e)}")
+
+
+# ─────────────────────────────────────────────────────────────
+# Endpoint: download laporan PDF
+# ─────────────────────────────────────────────────────────────
+@router.post("/api/download-pdf/")
+def download_pdf(data: PDFDownloadRequest):
+    try:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("helvetica", size=10)
+
+        # 1. Header (Kop Surat)
+        pdf.set_font("helvetica", "B", 14)
+        pdf.cell(0, 8, "PUSAT RADIOLOGI DIGITAL & DIAGNOSTIK AI", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.set_font("helvetica", size=9)
+        pdf.cell(0, 5, "Jl. Semilasari Barat No. 88, Sektor Kecerdasan Buatan, Denpasar", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.cell(0, 5, "Email: support@brainscan.ai | Telp: (021) 555-2026", new_x="LMARGIN", new_y="NEXT", align="C")
+
+        pdf.ln(3)
+        pdf.line(10, pdf.get_y(), 200, pdf.get_y())
+        pdf.ln(5)
+
+        # 2. Document Title
+        pdf.set_font("helvetica", "B", 12)
+        pdf.cell(0, 7, "DOKUMEN LAPORAN HASIL PEMERIKSAAN RADIOLOGI (OPINI AI)", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.ln(4)
+
+        # 3. Patient Details
+        pdf.set_font("helvetica", "B", 10)
+        pdf.cell(0, 6, "I. IDENTITAS PASIEN & PEMERIKSAAN", new_x="LMARGIN", new_y="NEXT")
+        pdf.set_font("helvetica", size=9)
+
+        details = [
+            ("Nama Pasien", data.patient_name, "Jenis Kelamin", data.patient_gender),
+            ("Umur", f"{data.patient_age} Tahun", "Tanggal Lahir", data.patient_birth_date),
+            ("NIK Pasien", data.patient_nik, "No. Telepon", data.patient_phone),
+            ("Alamat", data.patient_address, "Tanggal Analisis", tanggal_indonesia_sekarang()),
+        ]
+
+        col_width = 40
+        val_width = 55
+        for row in details:
+            pdf.set_font("helvetica", "B", 9)
+            pdf.cell(col_width, 6, f"{row[0]}:", border=0)
+            pdf.set_font("helvetica", "", 9)
+            pdf.cell(val_width, 6, str(row[1]), border=0)
+
+            pdf.set_font("helvetica", "B", 9)
+            pdf.cell(col_width, 6, f"{row[2]}:", border=0)
+            pdf.set_font("helvetica", "", 9)
+            pdf.cell(val_width, 6, str(row[3]), border=0, new_x="LMARGIN", new_y="NEXT")
+
+        pdf.ln(3)
+        pdf.line(10, pdf.get_y(), 200, pdf.get_y())
+        pdf.ln(5)
+
+        # 4. Report Text Content
+        pdf.set_font("helvetica", "B", 10)
+        pdf.cell(0, 6, "II. LAPORAN PEMERIKSAAN (RADIOLOGY REPORT)", new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(2)
+
+        pdf.set_font("helvetica", "", 9.5)
+        lines = data.report_text.split("\n")
+        for line in lines:
+            stripped = line.strip()
+            if stripped.startswith(("1. ", "2. ", "3. ", "4. ")):
+                pdf.ln(2)
+                pdf.set_font("helvetica", "B", 10)
+                pdf.multi_cell(0, 6, line, new_x="LMARGIN", new_y="NEXT")
+                pdf.set_font("helvetica", "", 9.5)
+            elif stripped.startswith(("* ", "- ")):
+                pdf.set_font("helvetica", "", 9.5)
+                pdf.set_x(15)
+                pdf.multi_cell(0, 5, line, new_x="LMARGIN", new_y="NEXT")
+            elif stripped.startswith(("*Catatan:", "Catatan:")):
+                pdf.ln(4)
+                pdf.set_font("helvetica", "I", 8.5)
+                pdf.multi_cell(0, 4.5, line, new_x="LMARGIN", new_y="NEXT")
+            else:
+                pdf.multi_cell(0, 5, line, new_x="LMARGIN", new_y="NEXT")
+
+        # 5. Signatures
+        pdf.ln(15)
+        current_y = pdf.get_y()
+
+        if current_y > 240:
+            pdf.add_page()
+            current_y = pdf.get_y()
+
+        pdf.set_font("helvetica", "", 9.5)
+        pdf.set_xy(130, current_y)
+        pdf.cell(60, 5, f"Denpasar, {tanggal_indonesia_sekarang()}", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.set_x(130)
+        pdf.cell(60, 5, "Pusat Radiologi Digital & Diagnostik AI", new_x="LMARGIN", new_y="NEXT", align="C")
+
+        pdf.ln(10)
+        pdf.set_x(130)
+        pdf.set_font("helvetica", "B", 9.5)
+        pdf.cell(60, 5, "dr. _________________________, Sp.Rad", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.set_x(130)
+        pdf.set_font("helvetica", "", 8.5)
+        pdf.cell(60, 5, "NIP. ___________________________", new_x="LMARGIN", new_y="NEXT", align="C")
+
+        pdf_bytes = bytes(pdf.output())
+
+        return StreamingResponse(
+            io.BytesIO(pdf_bytes),
+            media_type="application/pdf",
+            headers={"Content-Disposition": "attachment; filename=Laporan_Radiologi_BrainScan.pdf"},
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Gagal memproses PDF: {str(e)}")

app.py

@@ -0,0 +1,83 @@
+"""
+app.py
+------
+Entry point aplikasi BrainScan AI.
+
+Tanggung jawab file ini HANYA:
+  1. Membuat instance FastAPI
+  2. Mengatur CORS
+  3. Membuat folder output yang diperlukan
+  4. Menyertakan (include) seluruh route dari api.py
+  5. Mount static files (frontend) & folder figures (heatmap)
+
+Semua logika endpoint (load model, /api/analyze/, dll) ada di api.py —
+file ini sengaja dibuat "tipis", cuma perakitan (wiring) doang.
+
+Jalankan dari root proyek (folder yang berisi folder src/):
+    uvicorn src.app:app --reload
+    # atau
+    python -m src.app
+"""
+
+import os
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+from src.config import OUTPUT_DIR
+from src.api import router as api_router
+
+# ─────────────────────────────────────────────────────────────
+# 1. Inisialisasi Aplikasi FastAPI
+# ─────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="BrainScan AI Framework API",
+    description="API untuk analisis otomatis CT-Scan & MRI menggunakan arsitektur Hybrid CNN-Transformer",
+    version="1.0",
+)
+
+# ─────────────────────────────────────────────────────────────
+# 2. CORS — biar frontend (domain/origin manapun) bisa akses API ini
+# ─────────────────────────────────────────────────────────────
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ─────────────────────────────────────────────────────────────
+# 3. Folder output yang diperlukan saat runtime
+# ─────────────────────────────────────────────────────────────
+os.makedirs(os.path.join(OUTPUT_DIR, "figures"), exist_ok=True)
+os.makedirs("temp_uploads", exist_ok=True)
+
+# ─────────────────────────────────────────────────────────────
+# 4. Sambungkan semua endpoint dari api.py
+#    (mengimpor src.api otomatis menjalankan proses load model
+#    di dalamnya, lihat komentar di bagian atas api.py)
+# ─────────────────────────────────────────────────────────────
+app.include_router(api_router)
+
+# ─────────────────────────────────────────────────────────────
+# 5. Mount static files
+#    - /outputs/figures -> hasil heatmap Grad-CAM (fallback akses langsung)
+#    - /                 -> frontend (index.html, app.js, index.css)
+#    Urutan penting: mount("/") harus PALING TERAKHIR supaya tidak
+#    "menutupi" route API yang sudah didaftarkan lewat include_router.
+# ─────────────────────────────────────────────────────────────
+app.mount(
+    "/outputs/figures",
+    StaticFiles(directory=os.path.join(OUTPUT_DIR, "figures")),
+    name="figures",
+)
+app.mount("/", StaticFiles(directory="src/static", html=True), name="static")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    # Jalankan dari ROOT proyek (bukan dari dalam folder src/):
+    #   uvicorn src.app:app --reload
+    uvicorn.run("src.app:app", host="127.0.0.1", port=8000, reload=True)

classifier_model.py

@@ -0,0 +1,286 @@
+"""
+classifier_model.py
+-------------------
+Arsitektur PERSIS SAMA dengan yang dipakai saat training di notebook
+(Hybrid_ViT_EfficientNet_Brain_Disease_FIXED.ipynb), supaya checkpoint
+hasil training (hybrid_vit_efficientnet_brain_best.pth) bisa di-load
+tanpa error "Missing/Unexpected key(s)".
+
+Arsitektur:
+  - EfficientNet-B3 (CNN backbone)        -> feature map lokal (1536 dim)
+  - Custom Vision Transformer (6 layer)    -> dibangun dari nol (bukan
+    ViT pretrained HuggingFace), beroperasi di atas feature map CNN
+  - Cross-Modal Attention Fusion           -> gabungkan fitur CNN + ViT
+  - Classifier Head: Linear -> GELU -> BatchNorm1d -> Dropout -> Linear
+"""
+
+import logging
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+try:
+    from torchvision.models import efficientnet_b3, EfficientNet_B3_Weights
+    HAS_WEIGHTS = True
+except ImportError:
+    from torchvision.models import efficientnet_b3
+    HAS_WEIGHTS = False
+
+from src.config import NUM_CLASSES, IMG_SIZE
+
+logger = logging.getLogger("brain_pipeline")
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  SUB-MODULES (identik dengan notebook training)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class PatchEmbedding(nn.Module):
+    def __init__(self, in_channels=1536, patch_size=1, embed_dim=768):
+        super().__init__()
+        self.proj = nn.Conv2d(in_channels, embed_dim,
+                               kernel_size=patch_size, stride=patch_size)
+
+    def forward(self, x):
+        x = self.proj(x)
+        x = x.flatten(2).transpose(1, 2)
+        return x
+
+
+class MultiHeadSelfAttention(nn.Module):
+    def __init__(self, embed_dim=768, num_heads=12, dropout=0.1):
+        super().__init__()
+        assert embed_dim % num_heads == 0
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
+        self.scale = self.head_dim ** -0.5
+        self.qkv = nn.Linear(embed_dim, embed_dim * 3)
+        self.proj = nn.Linear(embed_dim, embed_dim)
+        self.drop = nn.Dropout(dropout)
+
+    def forward(self, x, return_attn: bool = False):
+        B, N, C = x.shape
+        qkv = (self.qkv(x)
+               .reshape(B, N, 3, self.num_heads, self.head_dim)
+               .permute(2, 0, 3, 1, 4))
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        attn = (q @ k.transpose(-2, -1)) * self.scale
+        attn = attn.softmax(dim=-1)
+        attn = self.drop(attn)
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        if return_attn:
+            return x, attn  # attn: [B, num_heads, N, N] -- dipakai buat heatmap
+        return x
+
+
+class TransformerBlock(nn.Module):
+    def __init__(self, embed_dim=768, num_heads=12, mlp_ratio=4.0, dropout=0.1):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(embed_dim)
+        self.attn  = MultiHeadSelfAttention(embed_dim, num_heads, dropout)
+        self.norm2 = nn.LayerNorm(embed_dim)
+        hidden = int(embed_dim * mlp_ratio)
+        self.mlp = nn.Sequential(
+            nn.Linear(embed_dim, hidden),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden, embed_dim),
+            nn.Dropout(dropout),
+        )
+
+    def forward(self, x, return_attn: bool = False):
+        if return_attn:
+            attn_out, attn_weights = self.attn(self.norm1(x), return_attn=True)
+            x = x + attn_out
+            x = x + self.mlp(self.norm2(x))
+            return x, attn_weights
+        x = x + self.attn(self.norm1(x))
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+
+class CrossModalAttentionFusion(nn.Module):
+    def __init__(self, cnn_dim=1536, vit_dim=768, fusion_dim=512, dropout=0.3):
+        super().__init__()
+        self.cnn_proj = nn.Linear(cnn_dim, fusion_dim)
+        self.vit_proj = nn.Linear(vit_dim, fusion_dim)
+        self.attn = nn.Sequential(
+            nn.Linear(fusion_dim * 2, fusion_dim),
+            nn.ReLU(),
+            nn.Linear(fusion_dim, 2),
+            nn.Softmax(dim=-1),
+        )
+        self.norm = nn.LayerNorm(fusion_dim)
+        self.drop = nn.Dropout(dropout)
+
+    def forward(self, cnn_feat, vit_feat):
+        c = self.cnn_proj(cnn_feat)
+        v = self.vit_proj(vit_feat)
+        w = self.attn(torch.cat([c, v], dim=-1))
+        fused = w[:, 0:1] * c + w[:, 1:2] * v
+        fused = self.norm(fused)
+        fused = self.drop(fused)
+        return fused
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  MODEL UTAMA
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+class BrainHybridModel(nn.Module):
+    """
+    Nama class TETAP 'BrainHybridModel' (biar main.py/explainability.py
+    tidak perlu diubah), tapi ISI-nya sekarang identik dengan
+    HybridViTEfficientNet di notebook training.
+    """
+
+    def __init__(self, num_classes: int = NUM_CLASSES,
+                 efficientnet_variant: str = "b3",
+                 vit_embed_dim: int = 768,
+                 vit_num_heads: int = 12,
+                 vit_num_layers: int = 6,
+                 fusion_dim: int = 512,
+                 dropout: float = 0.3,
+                 freeze_backbone: bool = True):
+        super().__init__()
+
+        # 1. CNN backbone (EfficientNet-B3)
+        if HAS_WEIGHTS:
+            backbone = efficientnet_b3(weights=EfficientNet_B3_Weights.DEFAULT)
+        else:
+            backbone = efficientnet_b3(pretrained=True)
+        self.features = backbone.features
+        self.cnn_out = 1536
+
+        # 2. ViT branch (custom, dibangun dari feature map CNN)
+        self.patch_embed = PatchEmbedding(self.cnn_out, patch_size=1,
+                                           embed_dim=vit_embed_dim)
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, vit_embed_dim))
+        nn.init.trunc_normal_(self.cls_token, std=0.02)
+        num_patches = (IMG_SIZE // 32) ** 2
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, vit_embed_dim))
+        nn.init.trunc_normal_(self.pos_embed, std=0.02)
+        self.pos_drop = nn.Dropout(dropout)
+        self.blocks = nn.ModuleList([
+            TransformerBlock(vit_embed_dim, vit_num_heads, dropout=dropout)
+            for _ in range(vit_num_layers)
+        ])
+        self.vit_norm = nn.LayerNorm(vit_embed_dim)
+
+        # 3. Fusion
+        self.fusion = CrossModalAttentionFusion(
+            cnn_dim=self.cnn_out, vit_dim=vit_embed_dim,
+            fusion_dim=fusion_dim, dropout=dropout)
+
+        # 4. Classifier head
+        self.classifier = nn.Sequential(
+            nn.Linear(fusion_dim, 256),
+            nn.GELU(),
+            nn.BatchNorm1d(256),
+            nn.Dropout(dropout),
+            nn.Linear(256, num_classes),
+        )
+
+        # Freeze/unfreeze backbone (opsional, hanya relevan kalau fine-tune ulang)
+        if freeze_backbone:
+            for param in self.features.parameters():
+                param.requires_grad = False
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        feat_map = self.features(x)
+        cnn_feat = F.adaptive_avg_pool2d(feat_map, 1).flatten(1)
+        patches = self.patch_embed(feat_map)
+        cls = self.cls_token.expand(x.size(0), -1, -1)
+        tokens = torch.cat([cls, patches], dim=1)
+        tokens = tokens + self.pos_embed
+        tokens = self.pos_drop(tokens)
+        for blk in self.blocks:
+            tokens = blk(tokens)
+        tokens = self.vit_norm(tokens)
+        vit_feat = tokens[:, 0]
+        fused = self.fusion(cnn_feat, vit_feat)
+        logits = self.classifier(fused)
+        return logits
+
+    def forward_with_attention(self, x: torch.Tensor):
+        """
+        Sama seperti forward(), tapi juga mengembalikan attention weights
+        dari layer Transformer TERAKHIR -- dipakai untuk bikin heatmap
+        'Peta Atensi Model' di explainability.py.
+
+        Return:
+            logits: [B, num_classes]
+            last_attn: [B, num_heads, seq_len, seq_len]
+        """
+        feat_map = self.features(x)
+        cnn_feat = F.adaptive_avg_pool2d(feat_map, 1).flatten(1)
+        patches = self.patch_embed(feat_map)
+        cls = self.cls_token.expand(x.size(0), -1, -1)
+        tokens = torch.cat([cls, patches], dim=1)
+        tokens = tokens + self.pos_embed
+        tokens = self.pos_drop(tokens)
+
+        last_attn = None
+        for i, blk in enumerate(self.blocks):
+            if i == len(self.blocks) - 1:
+                tokens, last_attn = blk(tokens, return_attn=True)
+            else:
+                tokens = blk(tokens)
+        tokens = self.vit_norm(tokens)
+        vit_feat = tokens[:, 0]
+        fused = self.fusion(cnn_feat, vit_feat)
+        logits = self.classifier(fused)
+        return logits, last_attn
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  UTILITIES
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+def count_parameters(model: nn.Module):
+    total     = sum(p.numel() for p in model.parameters())
+    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    return total, trainable, total - trainable
+
+
+def print_model_info(model: nn.Module, device: str):
+    try:
+        from src.config import BATCH_SIZE, LR, EPOCHS, IMG_SIZE
+    except ImportError:
+        BATCH_SIZE, LR, EPOCHS, IMG_SIZE = 16, 5e-5, 30, 224
+
+    total, trainable, frozen = count_parameters(model)
+    sep70 = "=" * 70
+    logger.info("\n" + sep70)
+    logger.info("  INFORMASI MODEL")
+    logger.info(sep70)
+    col = 30
+    fields = [
+        ("Model Name",              "EfficientNet-B3 + Custom Vision Transformer (Hybrid)"),
+        ("Architecture",            "EfficientNet-B3 Features + Custom ViT (6 layer) -> Cross-Modal Fusion -> MLP Head"),
+        ("Jumlah Parameter",        f"{total:,}"),
+        ("Trainable Parameter",     f"{trainable:,}"),
+        ("Non-Trainable Parameter", f"{frozen:,}"),
+        ("Image Size",              f"{IMG_SIZE} x {IMG_SIZE} px"),
+        ("Batch Size",              str(BATCH_SIZE)),
+        ("Learning Rate",           str(LR)),
+        ("Epoch",                   str(EPOCHS)),
+        ("Device",                  device.upper()),
+    ]
+    for k, v in fields:
+        logger.info(f"  {k:<{col}}: {v}")
+    logger.info("")
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  QUICK SANITY CHECK
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+if __name__ == "__main__":
+    model = BrainHybridModel()
+    dummy = torch.randn(2, 3, IMG_SIZE, IMG_SIZE)
+    out = model(dummy)
+    print(f"Hybrid Model OK! Output shape: {out.shape}")
+    total, trainable, frozen = count_parameters(model)
+    print(f"Total: {total:,} | Trainable: {trainable:,} | Frozen: {frozen:,}")

config.py

@@ -0,0 +1,168 @@
+"""
+src/config.py — Modul Konfigurasi Terpusat
+Brain Disease Classification Pipeline
+Vision Transformer (google/vit-base-patch16-224) Pretrained
+"""
+
+import os
+from pathlib import Path
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  HYPERPARAMETER UTAMA & SEED
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+SEED        = 42
+IMG_SIZE    = 224
+BATCH_SIZE  = 16
+NUM_CLASSES = 5
+LR          = 5e-5
+EPOCHS      = 30
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  GEMINI API KEY — WAJIB di-set lewat environment variable, JANGAN ditulis di sini
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Jangan pernah taruh API key asli langsung di source code (apalagi yang ikut
+# ter-commit ke git / ter-share ke orang lain) — siapa pun yang membaca file
+# ini bisa memakai kuota/API key milik Anda. Set lewat environment variable:
+#   export GEMINI_API_KEY="isi-key-anda"        (Linux/Mac)
+#   setx GEMINI_API_KEY "isi-key-anda"           (Windows)
+# Jika tidak di-set, sistem otomatis memakai generator laporan lokal (fallback)
+# di gemini_client.py — jadi aplikasi tetap berjalan tanpa Gemini API.
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  KELAS PENYAKIT OTAK (5 KELAS)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+CLASSES = [
+    "Alzheimer",
+    "Intracranial_Hemorrhage",
+    "Normal",
+    "Stroke_Iskemik",
+    "Tumor",
+]
+
+CLASS_DISPLAY = {
+    "Alzheimer":               "Alzheimer",
+    "Intracranial_Hemorrhage": "ICH",
+    "Normal":                  "Normal",
+    "Stroke_Iskemik":          "Ischemic Stroke",
+    "Tumor":                   "Brain Tumor",
+}
+
+CLASS_COLORS = ["#4E79A7", "#F28E2B", "#59A14F", "#E15759", "#B07AA1"]
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  STRUKTUR DIREKTORI PROYEK
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Posisi src/config.py adalah di proyek/src/, maka parent-nya adalah root proyek.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+# ── Data Directories ──────────────────────────────────────────────────────
+DATA_DIR           = BASE_DIR / "data"
+RAW_DIR            = DATA_DIR / "raw"
+INTERIM_DIR        = DATA_DIR / "interim"
+PROCESSED_DIR      = DATA_DIR / "processed"
+SPLITS_DIR         = DATA_DIR / "splits"
+
+# ── Output Directories ────────────────────────────────────────────────────
+OUTPUT_DIR         = BASE_DIR / "outputs"
+CHECKPOINT_DIR     = OUTPUT_DIR / "checkpoints"
+
+# ── Hugging Face Model Repo ────────────────────────────────────────────
+HF_REPO_ID = "Marksnb/brain-hybrid-efficientnet-vit"
+
+def download_model_from_hf(filename: str):
+    """
+    Download file .pth dari Hugging Face Hub kalau belum ada lokal.
+    Kalau gagal (file nggak ada di repo, dll) return None supaya
+    main.py bisa fallback ke perilaku lama (pakai bobot pretrained).
+    """
+    from huggingface_hub import hf_hub_download
+    local_path = CHECKPOINT_DIR / filename
+    if local_path.exists():
+        return str(local_path)
+    try:
+        os.makedirs(CHECKPOINT_DIR, exist_ok=True)
+        return hf_hub_download(
+            repo_id=HF_REPO_ID,
+            filename=filename,
+            local_dir=str(CHECKPOINT_DIR),
+        )
+    except Exception as e:
+        print(f"⚠️ Gagal download '{filename}' dari Hugging Face: {e}")
+        return None
+
+LOGS_DIR           = OUTPUT_DIR / "logs"
+FIGURES_DIR        = OUTPUT_DIR / "figures"
+TABLES_DIR         = OUTPUT_DIR / "tables"
+REPORTS_DIR        = OUTPUT_DIR / "reports"
+
+# ── File Paths Penting ────────────────────────────────────────────────────
+TRAINING_LOG_FILE    = LOGS_DIR        / "training.log"
+SPLITS_CSV_FILE      = SPLITS_DIR      / "train_val_test.csv"
+BEST_MODEL_PATH      = CHECKPOINT_DIR  / "best_hybrid_model.pth"
+
+# ─── Output Figures (nama file sesuai spesifikasi) ────────────────────────
+FIG_TRAINING_PERF      = FIGURES_DIR / "training_performance.png"
+FIG_CONFUSION_MATRIX   = FIGURES_DIR / "confusion_matrix.png"
+FIG_TRAINING_SUMMARY   = FIGURES_DIR / "training_summary.png"
+FIG_CLASS_DIST         = FIGURES_DIR / "class_distribution_before.png"
+FIG_AUGMENT_COMP       = FIGURES_DIR / "augmentation_comparison.png"
+
+# ─── Output Tables & Reports ──────────────────────────────────────────────
+TABLE_CLASSIF_REPORT   = TABLES_DIR  / "classification_report.csv"
+TABLE_DATASET_DIST     = TABLES_DIR  / "dataset_distribution.csv"
+TABLE_TRAINING_HISTORY = TABLES_DIR  / "training_history.csv"
+TABLE_TEST_EVAL        = TABLES_DIR  / "test_evaluation_results.csv"
+REPORT_AUDIT_SUMMARY = REPORTS_DIR / "audit_summary.json"
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  MODE TRAINING
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# QUICK_TEST=True  -> cuma proses 2 batch/epoch, buat tes cepat pipeline jalan/tidak
+# QUICK_TEST=False -> training penuh pakai seluruh data asli (WAJIB False untuk hasil final)
+QUICK_TEST = False
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  TARGET AUGMENTASI (class balancing)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Target jumlah sampel TRAIN per kelas setelah augmentasi offline.
+# Total akhir = AUGMENT_TARGET_PER_CLASS x NUM_CLASSES -- TAPI HANYA kalau
+# semua kelas raw < target ini. Kelas yang raw-nya sudah >= target TIDAK
+# dikurangi/dipotong (augment.py cuma menambah, tidak pernah membuang data).
+AUGMENT_TARGET_PER_CLASS = 19097
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  INIT_FOLDERS — Buat Semua Direktori Otomatis
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+def init_folders() -> None:
+    """
+    Membuat seluruh struktur folder proyek yang diperlukan jika belum ada.
+    """
+    all_dirs = [
+        RAW_DIR,
+        INTERIM_DIR,
+        PROCESSED_DIR,
+        SPLITS_DIR,
+        CHECKPOINT_DIR,
+        LOGS_DIR,
+        FIGURES_DIR,
+        TABLES_DIR,
+        REPORTS_DIR,
+    ]
+    for d in all_dirs:
+        os.makedirs(d, exist_ok=True)
+
+
+if __name__ == "__main__":
+    init_folders()
+    print("=" * 60)
+    print("  Modul Konfigurasi Terpusat (config.py)")
+    print("=" * 60)
+    print(f"  Root proyek : {BASE_DIR}")
+    print(f"  SEED        : {SEED}")
+    print(f"  IMG_SIZE    : {IMG_SIZE}")
+    print(f"  BATCH_SIZE  : {BATCH_SIZE}")
+    print(f"  NUM_CLASSES : {NUM_CLASSES}")
+    print(f"  EPOCHS      : {EPOCHS}")
+    print("  Struktur folder berhasil diperiksa/dibuat.")
+    print("=" * 60)

database.py

@@ -0,0 +1,185 @@
+import sqlite3
+import os
+from src.config import DATA_DIR
+
+DB_PATH = os.path.join(DATA_DIR, "brainscan.db")
+
+def get_db_connection():
+    """Membuka koneksi ke database SQLite dan mengembalikan objek koneksi"""
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row  # Mengembalikan hasil query sebagai dict-like object
+    return conn
+
+def init_db():
+    """Menginisialisasi tabel-tabel di database jika belum ada"""
+    # Pastikan direktori database ada
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    # 1. Tabel Pasien (Patients)
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS patients (
+        nik TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        age INTEGER,
+        birth_date TEXT,
+        gender TEXT,
+        address TEXT,
+        phone TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+    """)
+    
+    # 2. Tabel Riwayat Scan (Scans)
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS scans (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        patient_nik TEXT NOT NULL,
+        filename TEXT,
+        modality TEXT,
+        predicted_class TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        radiology_report TEXT,
+        original_image_b64 TEXT,
+        heatmap_image_b64 TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (patient_nik) REFERENCES patients(nik) ON DELETE CASCADE
+    )
+    """)
+    
+    # 3. Tabel Distribusi Dataset
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS dataset_distribution (
+        kelas TEXT PRIMARY KEY,
+        sebelum_balancing INTEGER,
+        setelah_balancing INTEGER
+    )
+    """)
+
+    # 4. Tabel Histori Pelatihan
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS training_history (
+        epoch INTEGER PRIMARY KEY,
+        train_loss REAL,
+        val_loss REAL,
+        train_acc REAL,
+        val_acc REAL,
+        train_f1 REAL,
+        val_f1 REAL,
+        epoch_time_seconds REAL
+    )
+    """)
+
+    # 5. Tabel Hasil Evaluasi Uji (Confusion Matrix)
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS test_evaluation_results (
+        actual_class TEXT,
+        predicted_class TEXT,
+        count INTEGER,
+        PRIMARY KEY (actual_class, predicted_class)
+    )
+    """)
+    
+    conn.commit()
+    conn.close()
+    print(f"Database berhasil diinisialisasi di: {DB_PATH}")
+
+def save_dataset_distribution_to_db(df):
+    """Menyimpan data distribusi dataset ke database"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM dataset_distribution")
+    for _, row in df.iterrows():
+        cursor.execute("""
+        INSERT INTO dataset_distribution (kelas, sebelum_balancing, setelah_balancing)
+        VALUES (?, ?, ?)
+        """, (row["Kelas"], int(row["Sebelum_Balancing"]), int(row["Setelah_Balancing"])))
+    conn.commit()
+    conn.close()
+
+def save_training_history_to_db(df):
+    """Menyimpan data histori training ke database"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM training_history")
+    for _, row in df.iterrows():
+        cursor.execute("""
+        INSERT INTO training_history (epoch, train_loss, val_loss, train_acc, val_acc, train_f1, val_f1, epoch_time_seconds)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """, (int(row["Epoch"]), float(row["Train_Loss"]), float(row["Val_Loss"]), float(row["Train_Acc"]), float(row["Val_Acc"]), float(row["Train_F1"]), float(row["Val_F1"]), float(row["Epoch_Time_Seconds"])))
+    conn.commit()
+    conn.close()
+
+def save_test_evaluation_to_db(cm, classes):
+    """Menyimpan data confusion matrix ke database"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM test_evaluation_results")
+    for i, act_cls in enumerate(classes):
+        for j, pred_cls in enumerate(classes):
+            cursor.execute("""
+            INSERT INTO test_evaluation_results (actual_class, predicted_class, count)
+            VALUES (?, ?, ?)
+            """, (act_cls, pred_cls, int(cm[i, j])))
+    conn.commit()
+    conn.close()
+
+def upsert_patient(nik, name, age=None, birth_date=None, gender=None, address=None, phone=None):
+    """Menyisipkan atau memperbarui data pasien berdasarkan NIK"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+    INSERT INTO patients (nik, name, age, birth_date, gender, address, phone)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(nik) DO UPDATE SET
+        name = excluded.name,
+        age = excluded.age,
+        birth_date = excluded.birth_date,
+        gender = excluded.gender,
+        address = excluded.address,
+        phone = excluded.phone
+    """, (nik, name, age, birth_date, gender, address, phone))
+    conn.commit()
+    conn.close()
+
+def get_patient(nik):
+    """Mengambil informasi pasien berdasarkan NIK"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM patients WHERE nik = ?", (nik,))
+    row = cursor.fetchone()
+    conn.close()
+    if row:
+        return dict(row)
+    return None
+
+def add_scan_record(patient_nik, filename, modality, predicted_class, confidence, report_text, original_b64=None, heatmap_b64=None):
+    """Menyimpan data riwayat pemeriksaan scan otak"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+    INSERT INTO scans (patient_nik, filename, modality, predicted_class, confidence, radiology_report, original_image_b64, heatmap_image_b64)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    """, (patient_nik, filename, modality, predicted_class, confidence, report_text, original_b64, heatmap_b64))
+    conn.commit()
+    conn.close()
+
+def get_patient_history(nik):
+    """Mengambil riwayat scan dari pasien tertentu berdasarkan NIK"""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+    SELECT s.*, p.name, p.age, p.gender, p.birth_date, p.address, p.phone 
+    FROM scans s
+    JOIN patients p ON s.patient_nik = p.nik
+    WHERE s.patient_nik = ?
+    ORDER BY s.created_at DESC
+    """, (nik,))
+    rows = cursor.fetchall()
+    conn.close()
+    return [dict(row) for row in rows]
+
+# Inisialisasi DB saat modul di-import pertama kali
+init_db()

explainability.py

@@ -0,0 +1,80 @@
+import os
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from src.preprocess import val_transforms
+from src.models.classifier_model import BrainHybridModel
+from src.config import OUTPUT_DIR, CHECKPOINT_DIR
+
+def generate_attention_heatmap(image_path, save_name="attention_map.png"):
+    """Menghasilkan peta panas (heatmap) fokus perhatian model AI pada gambar otak"""
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # 1. Muat dan ubah gambar menjadi tensor
+    orig_image = Image.open(image_path).convert('RGB')
+    tensor_image = val_transforms(orig_image).unsqueeze(0).to(device)
+    
+    # 2. Muat model dan bobot terbaik
+    model = BrainHybridModel().to(device)
+    checkpoint_path = os.path.join(CHECKPOINT_DIR, "best_hybrid_model.pth")
+    if os.path.exists(checkpoint_path):
+        try:
+            model.load_state_dict(torch.load(checkpoint_path, map_location=device))
+        except RuntimeError:
+            print("Warning: Checkpoint tidak kompatibel dengan arsitektur ViT baru, menggunakan bobot pretrained bawaan.")
+    model.eval()
+    
+    # 3. Ekstraksi attention weights dari ViT (custom Transformer block terakhir)
+    with torch.no_grad():
+        # forward_with_attention mengembalikan (logits, attn) dari block terakhir
+        # attn shape: [B, num_heads, seq_len, seq_len]
+        _, attentions = model.forward_with_attention(tensor_image)
+
+        # Rata-ratakan semua attention heads
+        avg_attn = attentions.squeeze(0).mean(dim=0)      # [seq_len, seq_len]
+
+        # Ambil attention dari CLS token (index 0) ke semua patch tokens
+        cls_attn = avg_attn[0, 1:]  # [num_patches] (buang CLS-to-CLS)
+
+        # Feature map EfficientNet-B3 di 224x224 -> grid 7x7 = 49 patch tokens
+        num_patches = int(cls_attn.shape[0] ** 0.5)
+        heatmap = cls_attn.reshape(num_patches, num_patches).cpu().numpy()
+        
+        # Normalisasi peta panas antara nilai 0 hingga 1
+        heatmap = np.maximum(heatmap, 0)
+        heatmap /= np.max(heatmap) if np.max(heatmap) != 0 else 1.0
+
+    # 4. Gambar dan gabungkan citra asli dengan peta panas
+    fig, axes = plt.subplots(1, 2, figsize=(10, 5))
+    axes[0].imshow(orig_image)
+    axes[0].set_title("Gambar Medis Asli")
+    axes[0].axis('off')
+    
+    # Ubah ukuran peta panas agar pas dengan dimensi gambar asli
+    heatmap_resized = np.array(Image.fromarray(heatmap).resize(orig_image.size, Image.Resampling.BILINEAR))
+    
+    axes[1].imshow(orig_image)
+    axes[1].imshow(heatmap_resized, cmap='jet', alpha=0.4) # Overlay warna transparan
+    axes[1].set_title("Peta Fokus Atensi AI (ViT Attention)")
+    axes[1].axis('off')
+    
+    # Simpan visualisasi ke folder outputs/figures/
+    figure_dir = os.path.join(OUTPUT_DIR, "figures")
+    os.makedirs(figure_dir, exist_ok=True)
+    save_path = os.path.join(figure_dir, save_name)
+    plt.savefig(save_path, bbox_inches='tight')
+    plt.close()
+    print(f"Sukses menghasilkan peta eksplanabilitas AI! Tersimpan di: {save_path}")
+
+if __name__ == "__main__":
+    # Mencari satu contoh gambar acak dari folder normal untuk uji coba modul
+    sample_dir = "data/raw/Normal"
+    if os.path.exists(sample_dir) and os.listdir(sample_dir):
+        first_img = os.listdir(sample_dir)[0]
+        full_path = os.path.join(sample_dir, first_img)
+        generate_attention_heatmap(full_path)
+    else:
+        print("Folder data/raw/Normal kosong atau tidak ditemukan untuk pengujian.")
+ 
+ 

fusion_blocks.py

@@ -0,0 +1,37 @@
+import torch
+import torch.nn as nn
+
+class CrossAttentionFusion(nn.Module):
+    """
+    Fuses features from two different sources (e.g. CNN features and ViT/Transformer features)
+    using Cross-Attention mechanism.
+    """
+    def __init__(self, d_model=1280, nhead=8, dropout=0.1):
+        super().__init__()
+        self.multihead_attn = nn.MultiheadAttention(embed_dim=d_model, num_heads=nhead, dropout=dropout, batch_first=True)
+        self.norm = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, query, key, value):
+        # query, key, value shape: [batch_size, seq_len, d_model]
+        attn_output, _ = self.multihead_attn(query, key, value)
+        x = query + self.dropout(attn_output)
+        x = self.norm(x)
+        return x
+
+class SimpleConcatFusion(nn.Module):
+    """
+    Simple concatenation of features followed by linear projection.
+    """
+    def __init__(self, in_features1, in_features2, out_features):
+        super().__init__()
+        self.fc = nn.Linear(in_features1 + in_features2, out_features)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.3)
+
+    def forward(self, feat1, feat2):
+        x = torch.cat([feat1, feat2], dim=-1)
+        x = self.fc(x)
+        x = self.relu(x)
+        x = self.dropout(x)
+        return x

gemini_client.py

@@ -0,0 +1,153 @@
+import os
+import google.generativeai as genai
+from src.config import CLASSES, GEMINI_API_KEY as CONFIG_API_KEY
+from src.prompts import build_radiology_prompt
+
+# Inisialisasi API Key Gemini
+# Prioritas: 1) config.py GEMINI_API_KEY  2) Environment Variable  3) Fallback lokal
+api_key = CONFIG_API_KEY or os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY")
+if api_key:
+    genai.configure(api_key=api_key)
+    print("Gemini API Client berhasil dikonfigurasi menggunakan API Key.")
+else:
+    print("Warning: GEMINI_API_KEY tidak ditemukan di config.py maupun environment. Mengaktifkan sistem laporan lokal fallback.")
+
+def generate_radiology_report(predicted_idx, confidence, modality="MRI"):
+    """
+    Menghasilkan laporan radiologi detail.
+    Mencoba menggunakan API Gemini terlebih dahulu, dan menggunakan generator lokal jika API tidak tersedia.
+    """
+    class_name = CLASSES[predicted_idx]
+    
+    # 1. Definisikan detail pola visual dan area atensi untuk prompt
+    suspected_patterns = {
+        "Alzheimer": "Atrofi kortikal difus bilateral, pelebaran sulkus otak, dan pembesaran sistem ventrikel (ventrikulomegali) kompensatorik.",
+        "Intracranial_Hemorrhage": "Lesi hiperdens akut (fokus pendarahan aktif) intraaksial/ekstraaksial dengan potensi efek massa.",
+        "Normal": "Arsitektur parenkim otak normal, batas substansia alba-grisea tegas, sistem ventrikel dan sulkus kortikal dalam batas normal.",
+        "Stroke_Iskemik": "Area hipodensitas fokal (infark serebri) akut/subakut yang sesuai dengan vaskularisasi arteri serebri tertentu.",
+        "Tumor": "Massa soliter/multipel intraaksial dengan edema perifokal (vasogenik) luas serta pendesakan garis tengah (midline shift)."
+    }
+    
+    attention_regions = {
+        "Alzheimer": "Lobus Temporal Medial, terutama daerah Hipokampus bilateral.",
+        "Intracranial_Hemorrhage": "Parenkim serebral (lobus frontal/temporal) atau ruang subdural/epidural.",
+        "Normal": "Seluruh parenkim serebri dan serebelum secara simetris.",
+        "Stroke_Iskemik": "Korteks serebri atau ganglia basalis (terutama teritori Arteri Serebri Media/MCA).",
+        "Tumor": "Lobus frontal/parietal parenkim serebral, atau fosa posterior serebelum."
+    }
+
+    result_data = {
+        "predicted_class": class_name,
+        "confidence": f"{confidence:.2f}%",
+        "visual_summary": {
+            "modality": modality,
+            "suspected_pattern": suspected_patterns.get(class_name, "Pola visual atipikal."),
+            "attention_region": attention_regions.get(class_name, "Area kortikal serebri.")
+        }
+    }
+
+    # Jika API key Gemini tersedia, panggil model Gemini
+    if api_key:
+        try:
+            prompt = build_radiology_prompt(result_data)
+            # Menggunakan gemini-1.5-flash untuk respon cepat dan andal
+            model = genai.GenerativeModel("gemini-1.5-flash")
+            response = model.generate_content(prompt)
+            if response.text:
+                return response.text.strip()
+        except Exception as e:
+            print(f"Gagal memanggil Gemini API: {str(e)}. Menggunakan laporan medis lokal.")
+
+    # 2. Generator Laporan Medis Lokal Fallback (Sangat Detail dan Profesional)
+    return get_local_fallback_report(class_name, confidence, modality, suspected_patterns[class_name], attention_regions[class_name])
+
+def get_local_fallback_report(class_name, confidence, modality, pattern, region):
+    """Menghasilkan teks laporan medis radiologi standar yang terstruktur"""
+    
+    indonesian_names = {
+        "Alzheimer": "Penyakit Alzheimer / Atrofi Serebral Kronis",
+        "Intracranial_Hemorrhage": "Pendarahan Intrakranial (Intracranial Hemorrhage)",
+        "Normal": "Kondisi Otak Normal (Normal Brain Scan)",
+        "Stroke_Iskemik": "Stroke Iskemik (Infark Serebri)",
+        "Tumor": "Neoplasma Otak / Tumor Serebral"
+    }
+    
+    display_name = indonesian_names.get(class_name, class_name)
+    
+    report = f"""LAPORAN RADIOLOGI EVALUASI SCAN OTAK
+Modalitas Pemeriksaan : {modality}-Scan Kepala (Brain Imaging)
+Identitas Temuan      : Deteksi Otomatis Sistem AI Terintegrasi
+Status AI             : Analisis Selesai (Confidence Level: {confidence:.2f}%)
+Dugaan Klinis Utama   : {display_name}
+
+1. RINGKASAN TEMUAN (FINDINGS SUMMARY):
+Pemeriksaan penunjang citra {modality} kepala menunjukkan adanya indikasi kelainan terfokus. Peta visual atensi AI (XAI) mendeteksi fokus anomali pada: {region}.
+Pola visual yang dominan diidentifikasi sebagai: '{pattern}'.
+
+2. ANALISIS KLINIS (CLINICAL ANALYSIS):"""
+
+    if class_name == "Alzheimer":
+        report += """
+* Tampak adanya reduksi volume parenkim otak global yang signifikan (Atrofi Serebral).
+* Sulkus kortikal serebri melebar disertai pendalaman girus serebri secara difus, menonjol di lobus temporal dan parietal.
+* Sistem ventrikel lateral kiri dan kanan melebar simetris, konsisten dengan hydrocephalus ex-vacuo sekunder akibat hilangnya jaringan otak.
+* Tidak ditemukan tanda-tanda pendarahan akut maupun space-occupying lesion (massa tumor)."""
+    
+    elif class_name == "Intracranial_Hemorrhage":
+        report += """
+* Tampak visualisasi area lesi densitas tinggi (hiperdens) homogen lokal pada jaringan parenkim otak.
+* Lesi disertai visualisasi edema perifokal (ring-like edema) tipis di sekitarnya.
+* Terdeteksi sedikit efek massa lokal berupa kompresi ringan pada sulkus serebri yang bersebelahan.
+* Rekomendasi perhatian ketat terhadap potensi peningkatan tekanan intrakranial (TIK)."""
+        
+    elif class_name == "Normal":
+        report += """
+* Parenkim serebri dan serebelum menunjukkan intensitas dan struktur sinyal homogen normal.
+* Batas substansia alba (white matter) dan grisea (grey matter) tegas dan simetris di kedua hemisfer serebri.
+* Sistem ventrikel lateral, ventrikel III, dan IV berada dalam posisi sentral dengan ukuran dan konfigurasi normal.
+* Tidak tampak area hipodensitas lokal (infark serebri), pendarahan intrakranial, maupun massa neoplasma yang dicurigai."""
+        
+    elif class_name == "Stroke_Iskemik":
+        report += """
+* Terdeteksi area lesi fokal hipodensitas parenkim serebri yang menunjukkan batas kurang tegas di daerah korteks/subkorteks.
+* Visualisasi lesi selaras dengan batas vaskularisasi suplai darah serebral, menandakan adanya hambatan perfusi arteri (iskemia akut/subakut).
+* Ditemukan edema sitotoksik minimal di area terinfark tanpa pergeseran midline serebri yang signifikan."""
+        
+    elif class_name == "Tumor":
+        report += """
+* Tampak massa lesi berbatas tegas dengan kontur ireguler yang menempati ruang serebral (space-occupying lesion).
+* Lesi dikelilingi oleh area edema vasogenik luas yang menekan sulkus kortikal dan jaringan parenkim sekitarnya.
+* Tampak kompresi parsial pada tanduk ventrikel lateral homolateral serta pergeseran minor garis tengah serebral (midline shift)."""
+
+    report += f"""
+
+3. TINGKAT KEYAKINAN (CONFIDENCE LEVEL ANALYSIS):
+* Model klasifikasi Vision Transformer (Marksnb/brain-hybrid-efficientnet-vit) mendeteksi tanda visual penyakit '{class_name}' dengan tingkat keyakinan {confidence:.2f}%.
+* Keakuratan klasifikasi divalidasi oleh cross-attention map yang secara presisi mengunci koordinat lesi di {region}.
+
+4. REKOMENDASI PEMERIKSAAN LANJUTAN (RECOMMENDATIONS):"""
+
+    if class_name == "Alzheimer":
+        report += """
+* Disarankan melakukan korelasi klinis melalui asesmen kognitif menyeluruh (MMSE, MoCA).
+* Evaluasi lanjutan dengan MRI resolusi tinggi (3T) sekuens volumetri hipokampus untuk menilai tingkat atrofi secara kuantitatif."""
+    elif class_name == "Intracranial_Hemorrhage":
+        report += """
+* Diperlukan tindakan darurat (cito) konsultasi dengan Dokter Spesialis Bedah Saraf.
+* Direkomendasikan CT-Scan non-kontras evaluasi ulang berkala (serial scan) dalam 12-24 jam untuk memantau perkembangan volume pendarahan."""
+    elif class_name == "Normal":
+        report += """
+* Tidak diperlukan evaluasi radiologi lanjutan segera jika tidak terdapat kecurigaan gejala klinis baru.
+* Disarankan kontrol berkala sesuai dengan anjuran dokter pengirim."""
+    elif class_name == "Stroke_Iskemik":
+        report += """
+* Disarankan melakukan CT-Angiografi (CTA) atau MR-Angiografi (MRA) segera untuk menilai patensi pembuluh darah serebral.
+* Pemeriksaan MRI kepala sekuens DWI/ADC (Diffusion-Weighted Imaging) untuk konfirmasi area infark akut (ischemic penumbra)."""
+    elif class_name == "Tumor":
+        report += """
+* Segera konsultasikan ke Spesialis Bedah Saraf / Onkologi.
+* Direkomendasikan pemeriksaan MRI kepala dengan kontras (gadolinium) sekuens multiplanar untuk detail morfologi neoplasma.
+* Rencanakan biopsi histopatologi untuk penentuan stadium dan jenis sel tumor secara definitif."""
+
+    report += "\n\n*Catatan: Laporan ini dihasilkan secara otomatis oleh sistem kecerdasan buatan (AI) sebagai opini sekunder radiologi. Hasil akhir harus selalu divalidasi dan ditandatangani oleh Dokter Spesialis Radiologi (Sp.Rad).*"
+    return report

main.py

@@ -0,0 +1,407 @@
+import os
+import torch
+import datetime
+import torch.nn.functional as F
+from fastapi import FastAPI, UploadFile, File, HTTPException, Form
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+import io
+import shutil
+import base64
+from pydantic import BaseModel
+
+from src.config import CLASSES, OUTPUT_DIR, CHECKPOINT_DIR, download_model_from_hf
+from src.preprocess import val_transforms, precheck_transforms
+from src.models.precheck_model import BrainPreCheckModel
+from src.models.classifier_model import BrainHybridModel
+from src.gemini_client import generate_radiology_report
+from src.explainability import generate_attention_heatmap
+from src.database import upsert_patient, get_patient, add_scan_record, get_patient_history
+
+# Inisialisasi Aplikasi FastAPI
+app = FastAPI(
+    title="BrainScan AI Framework API",
+    description="API untuk analisis otomatis CT-Scan & MRI menggunakan arsitektur Hybrid CNN-Transformer",
+    version="1.0"
+)
+
+# Model Data Pydantic untuk Input Pasien
+class PatientCreate(BaseModel):
+    nik: str
+    name: str
+    age: int = None
+    birth_date: str = None
+    gender: str = None
+    address: str = None
+    phone: str = None
+
+
+# Aktifkan CORS agar frontend dapat berkomunikasi dengan lancar
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Atur perangkat keras (GPU jika ada, jika tidak gunakan CPU)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+_HARI_ID  = ["Senin", "Selasa", "Rabu", "Kamis", "Jumat", "Sabtu", "Minggu"]
+_BULAN_ID = ["", "Januari", "Februari", "Maret", "April", "Mei", "Juni",
+             "Juli", "Agustus", "September", "Oktober", "November", "Desember"]
+
+
+def tanggal_indonesia_sekarang() -> str:
+    """Format tanggal sekarang, misal: 'Selasa, 7 Juli 2026' — bukan tanggal tetap."""
+    now = datetime.datetime.now()
+    return f"{_HARI_ID[now.weekday()]}, {now.day} {_BULAN_ID[now.month]} {now.year}"
+
+# Buat folder output yang diperlukan
+os.makedirs(os.path.join(OUTPUT_DIR, "figures"), exist_ok=True)
+os.makedirs("temp_uploads", exist_ok=True)
+
+# Muat model-model AI secara global pada startup server
+precheck_model = None
+hybrid_model = None
+
+try:
+    print("⏳ Memuat model Precheck...")
+    precheck_model = BrainPreCheckModel().to(device)
+    precheck_checkpoint = download_model_from_hf("best_precheck_model.pth") or os.path.join(CHECKPOINT_DIR, "best_precheck_model.pth")
+    if os.path.exists(precheck_checkpoint):
+        try:
+            precheck_model.load_state_dict(torch.load(precheck_checkpoint, map_location=device))
+            print(f"Sukses memuat bobot model Precheck dari {precheck_checkpoint}")
+        except RuntimeError as e:
+            print(f"Warning: Checkpoint precheck tidak kompatibel dengan arsitektur EfficientNet-B0 baru, menggunakan bobot pretrained bawaan.")
+    else:
+        print("Warning: best_precheck_model.pth tidak ditemukan, menggunakan bobot pretrained bawaan.")
+    precheck_model.eval()
+
+    print("Memuat model Utama Hybrid...")
+    hybrid_model = BrainHybridModel().to(device)
+    hybrid_checkpoint = download_model_from_hf("hybrid_vit_efficientnet_brain_best.pth") or os.path.join(CHECKPOINT_DIR, "best_hybrid_model.pth")
+    if os.path.exists(hybrid_checkpoint):
+        try:
+            ckpt = torch.load(hybrid_checkpoint, map_location=device)
+            if isinstance(ckpt, dict) and "model_state_dict" in ckpt:
+                hybrid_model.load_state_dict(ckpt["model_state_dict"])
+            else:
+                hybrid_model.load_state_dict(ckpt)
+            print(f"Sukses memuat bobot model Classifier utama dari {hybrid_checkpoint}")
+        except RuntimeError as e:
+            print(f"Warning: Checkpoint classifier tidak kompatibel dengan arsitektur baru: {str(e)}. Menggunakan bobot pretrained bawaan.")
+    else:
+        print("Warning: best_hybrid_model.pth tidak ditemukan, menggunakan bobot pretrained bawaan.")
+    hybrid_model.eval()
+    print("Seluruh model AI berhasil dimuat.")
+except Exception as e:
+    print(f"Gagal memuat model AI: {str(e)}")
+
+@app.get("/api/status")
+def get_status():
+    """Mengecek status online server dan ketersediaan model AI"""
+    return {
+        "status": "Online",
+        "precheck_model_loaded": precheck_model is not None,
+        "classifier_model_loaded": hybrid_model is not None,
+        "device": str(device)
+    }
+
+@app.post("/api/patients/")
+def register_patient(patient: PatientCreate):
+    """Menyimpan atau memperbarui data profil pasien"""
+    try:
+        upsert_patient(
+            nik=patient.nik,
+            name=patient.name,
+            age=patient.age,
+            birth_date=patient.birth_date,
+            gender=patient.gender,
+            address=patient.address,
+            phone=patient.phone
+        )
+        return {"status": "Success", "message": "Data pasien berhasil disimpan."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Gagal menyimpan data pasien: {str(e)}")
+
+@app.get("/api/patients/{nik}")
+def get_patient_info(nik: str):
+    """Mengambil data pasien berdasarkan NIK"""
+    patient = get_patient(nik)
+    if not patient:
+        raise HTTPException(status_code=404, detail="Pasien tidak ditemukan.")
+    return {"status": "Success", "patient": patient}
+
+@app.get("/api/patients/{nik}/history")
+def get_patient_scans_history(nik: str):
+    """Mengambil riwayat scan pasien berdasarkan NIK"""
+    try:
+        history = get_patient_history(nik)
+        return {"status": "Success", "history": history}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Gagal mengambil riwayat scan: {str(e)}")
+
+@app.post("/api/analyze/")
+async def analyze_brain_image(file: UploadFile = File(...), patient_nik: str = Form(None)):
+    """
+    Endpoint utama untuk mengunggah gambar scan otak, menjalankan pre-check,
+    menjalankan klasifikasi penyakit, memvisualisasikan atensi model (XAI),
+    dan menghasilkan laporan radiologi AI.
+    """
+    # 1. Validasi Ekstensi File
+    if not file.filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+
+        raise HTTPException(status_code=400, detail="Format file harus berupa gambar (PNG, JPG, JPEG).")
+        
+    try:
+        # 2. Simpan file unggahan sementara untuk visualisasi heatmap
+        temp_file_path = os.path.join("temp_uploads", file.filename)
+        with open(temp_file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # 3. Baca gambar untuk pemrosesan tensor PyTorch
+        image = Image.open(temp_file_path).convert("RGB")
+        # Dua tensor terpisah: precheck pakai normalisasi [0.5,0.5,0.5]
+        # (sesuai cara dia dilatih), hybrid pakai normalisasi ImageNet
+        # (sesuai cara model utama dilatih di notebook)
+        precheck_tensor = precheck_transforms(image).unsqueeze(0).to(device)
+        tensor_image = val_transforms(image).unsqueeze(0).to(device)
+        
+        # 4. TAHAP 1: Precheck (Menyaring Gambar Valid Brain Scan vs Gambar Noise/Invalid)
+        is_valid = True
+        precheck_prob_val = 0.99
+        if precheck_model is not None:
+            with torch.no_grad():
+                precheck_outputs = precheck_model(precheck_tensor)
+                precheck_prob = F.softmax(precheck_outputs, dim=1)
+                is_valid_idx = torch.argmax(precheck_prob, dim=1).item()
+                precheck_prob_val = precheck_prob[0][is_valid_idx].item()
+                # Indeks 1: Valid, Indeks 0: Invalid (Sesuai dengan dataset latihan precheck)
+                is_valid = (is_valid_idx == 1)
+
+        # Jika gambar dinyatakan invalid, hentikan proses analisis awal
+        if not is_valid:
+            # Hapus file sementara
+            if os.path.exists(temp_file_path):
+                os.remove(temp_file_path)
+            return {
+                "status": "Invalid",
+                "filename": file.filename,
+                "message": "Gambar tidak dikenali sebagai scan otak yang valid (CT-Scan/MRI). Hubungi Administrator.",
+                "precheck_confidence": f"{precheck_prob_val * 100:.2f}%"
+            }
+
+        # 5. TAHAP 2: Klasifikasi Utama (5 Kelas Penyakit Otak)
+        if hybrid_model is None:
+            raise HTTPException(status_code=500, detail="Model utama klasifikasi tidak termuat di server.")
+            
+        with torch.no_grad():
+            hybrid_outputs = hybrid_model(tensor_image)
+            hybrid_prob = F.softmax(hybrid_outputs, dim=1)
+            confidence, predicted_idx = torch.max(hybrid_prob, dim=1)
+            
+            confidence_score = confidence.item() * 100
+            predicted_class = CLASSES[predicted_idx.item()]
+            
+        # 6. TAHAP 3: Eksplanabilitas AI (XAI) - Hasilkan Peta Atensi Heatmap
+        heatmap_filename = f"heatmap_{os.path.splitext(file.filename)[0]}.png"
+        generate_attention_heatmap(temp_file_path, save_name=heatmap_filename)
+        
+        # 7. TAHAP 4: Kirim Hasil Ke Gemini / Laporan Lokal
+        modality = "CT" if "ct" in file.filename.lower() else "MRI"
+        report_text = generate_radiology_report(predicted_idx.item(), confidence_score, modality)
+        
+        # 8. Encode gambar visualisasi heatmap dan gambar asli menjadi base64 untuk dikirim langsung ke frontend
+        # Ini mencegah isu caching browser pada pemuatan statis
+        heatmap_path = os.path.join(OUTPUT_DIR, "figures", heatmap_filename)
+        
+        # Baca visualisasi heatmap
+        with open(heatmap_path, "rb") as img_file:
+            heatmap_base64 = base64.b64encode(img_file.read()).decode('utf-8')
+            
+        # Baca gambar asli
+        with open(temp_file_path, "rb") as img_file:
+            original_base64 = base64.b64encode(img_file.read()).decode('utf-8')
+
+        # Hapus file sementara setelah diproses
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+        # Simpan ke database jika patient_nik tersedia
+        if patient_nik:
+            try:
+                add_scan_record(
+                    patient_nik=patient_nik,
+                    filename=file.filename,
+                    modality=modality,
+                    predicted_class=predicted_class,
+                    confidence=confidence_score,
+                    report_text=report_text,
+                    original_b64=f"data:image/png;base64,{original_base64}",
+                    heatmap_b64=f"data:image/png;base64,{heatmap_base64}"
+                )
+            except Exception as db_err:
+                print(f"Gagal menyimpan riwayat scan ke database: {str(db_err)}")
+
+        # 9. Kembalikan respons akhir dalam format JSON
+        return {
+            "status": "Valid",
+            "filename": file.filename,
+            "modality_detected": modality,
+            "prediction": {
+                "class_name": predicted_class,
+                "class_index": predicted_idx.item(),
+                "confidence": f"{confidence_score:.2f}%"
+            },
+            "radiology_report": report_text,
+            "original_image_b64": f"data:image/png;base64,{original_base64}",
+            "heatmap_image_b64": f"data:image/png;base64,{heatmap_base64}"
+        }
+        
+    except Exception as e:
+        # Bersihkan jika ada file sementara tersisa
+        if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+        raise HTTPException(status_code=500, detail=f"Terjadi kesalahan internal analisis: {str(e)}")
+
+
+from fastapi.responses import StreamingResponse
+from fpdf import FPDF
+
+class PDFDownloadRequest(BaseModel):
+    patient_name: str
+    patient_age: str
+    patient_gender: str
+    patient_nik: str
+    patient_birth_date: str = ""
+    patient_address: str = ""
+    patient_phone: str = ""
+    report_text: str
+
+@app.post("/api/download-pdf/")
+def download_pdf(data: PDFDownloadRequest):
+    try:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("helvetica", size=10)
+        
+        # 1. Header (Kop Surat)
+        pdf.set_font("helvetica", "B", 14)
+        pdf.cell(0, 8, "PUSAT RADIOLOGI DIGITAL & DIAGNOSTIK AI", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.set_font("helvetica", size=9)
+        pdf.cell(0, 5, "Jl. Semilasari Barat No. 88, Sektor Kecerdasan Buatan, Denpasar", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.cell(0, 5, "Email: support@brainscan.ai | Telp: (021) 555-2026", new_x="LMARGIN", new_y="NEXT", align="C")
+        
+        # Line divider
+        pdf.ln(3)
+        pdf.line(10, pdf.get_y(), 200, pdf.get_y())
+        pdf.ln(5)
+        
+        # 2. Document Title
+        pdf.set_font("helvetica", "B", 12)
+        pdf.cell(0, 7, "DOKUMEN LAPORAN HASIL PEMERIKSAAN RADIOLOGI (OPINI AI)", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.ln(4)
+        
+        # 3. Patient Details
+        pdf.set_font("helvetica", "B", 10)
+        pdf.cell(0, 6, "I. IDENTITAS PASIEN & PEMERIKSAAN", new_x="LMARGIN", new_y="NEXT")
+        pdf.set_font("helvetica", size=9)
+        
+        # Create key-value table
+        details = [
+            ("Nama Pasien", data.patient_name, "Jenis Kelamin", data.patient_gender),
+            ("Umur", f"{data.patient_age} Tahun", "Tanggal Lahir", data.patient_birth_date),
+            ("NIK Pasien", data.patient_nik, "No. Telepon", data.patient_phone),
+            ("Alamat", data.patient_address, "Tanggal Analisis", tanggal_indonesia_sekarang())
+        ]
+        
+        col_width = 40
+        val_width = 55
+        for row in details:
+            pdf.set_font("helvetica", "B", 9)
+            pdf.cell(col_width, 6, f"{row[0]}:", border=0)
+            pdf.set_font("helvetica", "", 9)
+            pdf.cell(val_width, 6, str(row[1]), border=0)
+            
+            pdf.set_font("helvetica", "B", 9)
+            pdf.cell(col_width, 6, f"{row[2]}:", border=0)
+            pdf.set_font("helvetica", "", 9)
+            pdf.cell(val_width, 6, str(row[3]), border=0, new_x="LMARGIN", new_y="NEXT")
+            
+        pdf.ln(3)
+        pdf.line(10, pdf.get_y(), 200, pdf.get_y())
+        pdf.ln(5)
+        
+        # 4. Report Text Content
+        pdf.set_font("helvetica", "B", 10)
+        pdf.cell(0, 6, "II. LAPORAN PEMERIKSAAN (RADIOLOGY REPORT)", new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(2)
+        
+        pdf.set_font("helvetica", "", 9.5)
+        lines = data.report_text.split("\n")
+        for line in lines:
+            stripped = line.strip()
+            if stripped.startswith("1. ") or stripped.startswith("2. ") or stripped.startswith("3. ") or stripped.startswith("4. "):
+                pdf.ln(2)
+                pdf.set_font("helvetica", "B", 10)
+                pdf.multi_cell(0, 6, line, new_x="LMARGIN", new_y="NEXT")
+                pdf.set_font("helvetica", "", 9.5)
+            elif stripped.startswith("* ") or stripped.startswith("- "):
+                pdf.set_font("helvetica", "", 9.5)
+                pdf.set_x(15)
+                pdf.multi_cell(0, 5, line, new_x="LMARGIN", new_y="NEXT")
+            elif stripped.startswith("*Catatan:") or stripped.startswith("Catatan:"):
+                pdf.ln(4)
+                pdf.set_font("helvetica", "I", 8.5)
+                pdf.multi_cell(0, 4.5, line, new_x="LMARGIN", new_y="NEXT")
+            else:
+                pdf.multi_cell(0, 5, line, new_x="LMARGIN", new_y="NEXT")
+                
+        # 5. Signatures
+        pdf.ln(15)
+        current_y = pdf.get_y()
+        
+        if current_y > 240:
+            pdf.add_page()
+            current_y = pdf.get_y()
+            
+        pdf.set_font("helvetica", "", 9.5)
+        pdf.set_xy(130, current_y)
+        pdf.cell(60, 5, f"Denpasar, {tanggal_indonesia_sekarang()}", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.set_x(130)
+        pdf.cell(60, 5, "Pusat Radiologi Digital & Diagnostik AI", new_x="LMARGIN", new_y="NEXT", align="C")
+        
+        pdf.ln(10)
+        pdf.set_x(130)
+        pdf.set_font("helvetica", "B", 9.5)
+        pdf.cell(60, 5, "dr. _________________________, Sp.Rad", new_x="LMARGIN", new_y="NEXT", align="C")
+        pdf.set_x(130)
+        pdf.set_font("helvetica", "", 8.5)
+        pdf.cell(60, 5, "NIP. ___________________________", new_x="LMARGIN", new_y="NEXT", align="C")
+        
+        pdf_bytes = bytes(pdf.output())
+        
+        return StreamingResponse(
+            io.BytesIO(pdf_bytes),
+            media_type="application/pdf",
+            headers={"Content-Disposition": "attachment; filename=Laporan_Radiologi_BrainScan.pdf"}
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Gagal memproses PDF: {str(e)}")
+
+# Mount folder figures sebagai static files agar bisa diakses (opsional fallback)
+app.mount("/outputs/figures", StaticFiles(directory=os.path.join(OUTPUT_DIR, "figures")), name="figures")
+
+# Serve file static frontend secara langsung
+# html=True akan menyajikan index.html secara default jika rute / dipanggil
+app.mount("/", StaticFiles(directory="src/static", html=True), name="static")
+
+if __name__ == "__main__":
+    import uvicorn
+    # Jalankan server (jalankan dari root proyek: `python -m src.main`
+    # atau `uvicorn src.main:app --reload` dari folder root, BUKAN dari dalam folder src/)
+    uvicorn.run("src.main:app", host="127.0.0.1", port=8000, reload=True)

precheck_model.py

@@ -0,0 +1,65 @@
+"""
+precheck_model.py
+------------------
+Model Pre-Check (gatekeeper) berbasis EfficientNet-B0.
+
+Sesuai proposal, salah satu kebaruan utama proyek ini adalah modul pre-check
+BERBASIS EfficientNet-B0 (bukan Vision Transformer) untuk memverifikasi bahwa
+citra yang diunggah benar-benar CT-Scan/MRI otak yang valid, sebelum diteruskan
+ke model klasifikasi utama (BrainHybridModel). Tujuannya mengurangi risiko
+"halusinasi" model saat menerima citra non-otak atau modalitas yang tidak sesuai.
+
+Klasifikasi biner: indeks 0 = Invalid, indeks 1 = Valid.
+"""
+
+import torch
+import torch.nn as nn
+
+try:
+    from torchvision.models import efficientnet_b0, EfficientNet_B0_Weights
+    HAS_WEIGHTS = True
+except ImportError:
+    from torchvision.models import efficientnet_b0
+    HAS_WEIGHTS = False
+
+
+class BrainPreCheckModel(nn.Module):
+    """
+    Pre-Check Model berbasis EfficientNet-B0 (pretrained ImageNet) sebagai
+    backbone ekstraksi fitur, dengan head klasifikasi biner (Valid vs Invalid).
+
+    Nama atribut `backbone` dan `classifier` sengaja dipertahankan (sama seperti
+    versi sebelumnya) agar kompatibel dengan train_precheck.py, yang membekukan
+    `model.backbone` dan hanya melatih `model.classifier`.
+    """
+
+    def __init__(self):
+        super(BrainPreCheckModel, self).__init__()
+
+        # Backbone EfficientNet-B0 (pretrained ImageNet)
+        if HAS_WEIGHTS:
+            self.backbone = efficientnet_b0(weights=EfficientNet_B0_Weights.DEFAULT)
+        else:
+            self.backbone = efficientnet_b0(pretrained=True)
+
+        # EfficientNet-B0 classifier bawaan: Sequential(Dropout, Linear(1280, 1000))
+        in_features = self.backbone.classifier[1].in_features  # 1280
+        self.backbone.classifier = nn.Identity()
+
+        # Head klasifikasi biner: Valid (1) vs Invalid (0)
+        self.classifier = nn.Sequential(
+            nn.LayerNorm(in_features),
+            nn.Linear(in_features, 2),
+        )
+
+    def forward(self, x):
+        feats = self.backbone(x)       # [B, 1280]
+        return self.classifier(feats)  # [B, 2]
+
+
+if __name__ == "__main__":
+    # Uji coba apakah arsitektur model berhasil dimuat tanpa error
+    model = BrainPreCheckModel()
+    dummy_input = torch.randn(1, 3, 224, 224)  # Simulasi 1 gambar ukuran 224x224
+    output = model(dummy_input)
+    print(f"✨ Model Pre-Check (EfficientNet-B0) Sukses Dibuat! Ukuran Output: {output.shape}")

preprocess.py

@@ -0,0 +1,296 @@
+"""
+preprocess.py
+-------------
+Berisi:
+  - train_transforms / val_transforms : objek T.Compose siap pakai
+  - get_transforms()                  : mengembalikan (train_tf, val_tf)
+  - print_preprocessing_info()        : cetak ringkasan ke log
+  - plot_preprocessing_distribution() : grafik before/after balancing
+"""
+
+import os
+import cv2
+import logging
+import warnings
+import pandas as pd
+from pathlib import Path
+
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import torchvision.transforms as T
+
+from src.config import (
+    IMG_SIZE, CLASSES, CLASS_DISPLAY, CLASS_COLORS, FIGURES_DIR,
+    DATA_DIR, SPLITS_DIR,
+)
+
+warnings.filterwarnings("ignore")
+logger = logging.getLogger("brain_pipeline")
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  TRANSFORMS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+# Statistik normalisasi HARUS SAMA dengan yang dipakai saat training
+# (lihat notebook: IMAGENET_MEAN / IMAGENET_STD), karena backbone
+# EfficientNet-B3 di-pretrain pakai statistik ImageNet ini.
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD  = [0.229, 0.224, 0.225]
+
+# Transformasi untuk data latihan (dengan augmentasi spesifik citra medis)
+train_transforms = T.Compose([
+    T.Resize((IMG_SIZE, IMG_SIZE)),
+    T.RandomHorizontalFlip(p=0.5),
+    T.RandomRotation(degrees=8),  # Rotasi kecil spesifik medis
+    T.ColorJitter(brightness=0.15, contrast=0.15, saturation=0.0, hue=0.0), # Citra medis grayscale tidak memerlukan warna/hue/sat
+    T.RandomAffine(degrees=0, translate=(0.03, 0.03)), # Pergeseran kecil saja
+    T.GaussianBlur(kernel_size=(3, 3), sigma=(0.1, 0.5)), # Gaussian Blur halus
+    T.ToTensor(),
+    T.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+    T.RandomErasing(p=0.1, scale=(0.01, 0.05)), # Erasing diperkecil agar tidak menutupi patologi penting
+])
+
+# Transformasi untuk data validasi & pengujian (tanpa augmentasi)
+val_transforms = T.Compose([
+    T.Resize((IMG_SIZE, IMG_SIZE)),
+    T.ToTensor(),
+    T.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+])
+
+# Transform khusus untuk model Precheck -- model ini dilatih terpisah
+# (train_precheck.py) memakai normalisasi [0.5,0.5,0.5], BUKAN statistik
+# ImageNet, jadi harus dipakai transform yang beda dari val_transforms
+# di atas supaya konsisten dengan cara precheck model dilatih.
+precheck_transforms = T.Compose([
+    T.Resize((IMG_SIZE, IMG_SIZE)),
+    T.ToTensor(),
+    T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+])
+
+
+def get_transforms():
+    """Mengembalikan (train_transforms, val_transforms)."""
+    return train_transforms, val_transforms
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  PREPROCESSING INFO & PLOTS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+def print_preprocessing_info():
+    """Tampilkan ringkasan preprocessing & augmentasi ke log/terminal."""
+    from src.config import IMG_SIZE, BATCH_SIZE, LR, EPOCHS
+
+    sep70 = "=" * 70
+    logger.info("\n" + sep70)
+    logger.info("  PREPROCESSING ANALYSIS")
+    logger.info(sep70)
+
+    info = {
+        "Resize"              : f"{IMG_SIZE} x {IMG_SIZE} px",
+        "Normalisasi"         : "mean=[0.5,0.5,0.5]  std=[0.5,0.5,0.5]  (range -> [-1,1])",
+        "Augmentasi (train)"  : (
+            "RandomHorizontalFlip(p=0.5) | RandomRotation(+-15) | "
+            "ColorJitter(brightness=0.2, contrast=0.2) | "
+            "RandomAffine(translate=5%) | RandomErasing(p=0.2)"
+        ),
+        "Augmentasi (val/test)": "Resize + ToTensor + Normalize  (tanpa augmentasi)",
+        "Balancing"           : "WeightedRandomSampler  (per-class inverse-frequency weights)",
+    }
+    col = 25
+    for k, v in info.items():
+        logger.info(f"  {k:<{col}}: {v}")
+
+
+def plot_preprocessing_distribution(train_df_before, train_df_after):
+    """
+    Grafik distribusi kelas SEBELUM augmentasi (train_df_before, hasil scan
+    data/raw/ asli) vs SESUDAH augmentasi offline sungguhan (train_df_after,
+    hasil nyata dari augment.run_augmentation() -- bukan proyeksi/estimasi).
+    """
+    COLOR_CT = "#E15759"
+    COLOR_MRI = "#4E79A7"
+
+    before_mods = {
+        "Alzheimer": "MRI", "Intracranial_Hemorrhage": "CT",
+        "Normal": "MRI", "Stroke_Iskemik": "CT", "Tumor": "CT"
+    }
+
+    before_counts_s = train_df_before["label"].value_counts().reindex(CLASSES, fill_value=0)
+    after_counts_s  = train_df_after["label"].value_counts().reindex(CLASSES, fill_value=0)
+    before = before_counts_s.tolist()
+    after  = after_counts_s.tolist()
+    total_before = int(sum(before))
+    total_after  = int(sum(after))
+
+    labels = [f"{CLASS_DISPLAY.get(c, c)}\n({before_mods.get(c, 'MRI')})" for c in CLASSES]
+    colors = [COLOR_CT if before_mods.get(c, 'MRI') == 'CT' else COLOR_MRI for c in CLASSES]
+
+    x = np.arange(len(labels))
+
+    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+
+    # Kiri: Sebelum Augmentasi (Distribusi Asli Train)
+    bars_b = axes[0].bar(x, before, width=0.55, color=colors,
+                         edgecolor="white", linewidth=1.2)
+    for bar, val in zip(bars_b, before):
+        axes[0].text(bar.get_x() + bar.get_width() / 2,
+                     bar.get_height() + max(before, default=1) * 0.01,
+                     f"{val:,}", ha="center", va="bottom", fontsize=9, fontweight="bold")
+    axes[0].set_title("Sebelum Augmentasi  (Distribusi Asli Data Train)", fontsize=12, fontweight="bold")
+    axes[0].set_xticks(x)
+    axes[0].set_xticklabels(labels, rotation=15, ha="right")
+    axes[0].set_ylabel("Jumlah Sampel")
+    axes[0].grid(axis="y", alpha=0.3)
+    axes[0].set_ylim(0, max(before + after, default=1) * 1.15)
+
+    from matplotlib.patches import Patch
+    legend_elements = [
+        Patch(facecolor=COLOR_CT, edgecolor='white', label='CT Scan'),
+        Patch(facecolor=COLOR_MRI, edgecolor='white', label='MRI Otak')
+    ]
+    axes[0].legend(handles=legend_elements, loc="upper right")
+
+    # Kanan: Sesudah Augmentasi Offline (Hasil NYATA, bukan estimasi)
+    bars_a = axes[1].bar(x, after, width=0.55, color=colors,
+                         edgecolor="white", linewidth=1.2, alpha=0.85)
+    for bar, val in zip(bars_a, after):
+        axes[1].text(bar.get_x() + bar.get_width() / 2,
+                     bar.get_height() + max(before + after, default=1) * 0.01,
+                     f"{val:,}", ha="center", va="bottom", fontsize=9, fontweight="bold")
+    axes[1].set_title("Sesudah Augmentasi Offline  (Hasil Nyata)", fontsize=12, fontweight="bold")
+    axes[1].set_xticks(x)
+    axes[1].set_xticklabels(labels, rotation=15, ha="right")
+    axes[1].set_ylabel("Jumlah Sampel")
+    axes[1].grid(axis="y", alpha=0.3)
+    axes[1].set_ylim(0, max(before + after, default=1) * 1.15)
+    axes[1].legend(handles=legend_elements, loc="upper right")
+
+    axes[1].text(0.5, 0.90, f"Total Data Train Setelah Augmentasi = {total_after:,} data",
+                 transform=axes[1].transAxes, ha="center", va="center",
+                 color="#D62728", fontsize=11, fontweight="bold",
+                 bbox=dict(facecolor='white', alpha=0.8, edgecolor='#D62728', boxstyle='round,pad=0.5'))
+
+    fig.suptitle(f"Distribusi Data CT Scan & MRI Sebelum ({total_before:,}) dan Sesudah ({total_after:,}) Augmentasi",
+                 fontsize=14, fontweight="bold", y=1.02)
+    fig.tight_layout()
+
+    out = Path(FIGURES_DIR) / "preprocessing_distribution.png"
+    fig.savefig(out, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    logger.info(f"  Grafik preprocessing disimpan -> {out}")
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#  BRAIN SCAN CROP CONTOUR
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+def crop_brain_contour(img):
+    """
+    Mendeteksi area scan otak sirkular di dalam gambar dan memotong (crop)
+    area luar seperti taskbar desktop, bingkai window, atau ruang hitam berlebih.
+    """
+    if img is None:
+        return None
+        
+    h, w, c = img.shape
+    
+    # Convert to grayscale
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    
+    # Threshold to binary (threshold 20, max 255)
+    _, thresh = cv2.threshold(gray, 20, 255, cv2.THRESH_BINARY)
+    
+    # Find contours
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return img
+        
+    # Sort contours by area descending and find the largest
+    contours = sorted(contours, key=cv2.contourArea, reverse=True)
+    
+    # Get bounding box of the largest contour (the brain scan area)
+    x, y, cw, ch = cv2.boundingRect(contours[0])
+    
+    # Check if the bounding box is valid and reasonably large
+    # (e.g. at least 30% of original width/height to avoid tiny text contours)
+    if cw > w * 0.3 and ch > h * 0.3:
+        # Add a padding of 5 pixels to avoid clipping the edges
+        pad = 5
+        x = max(0, x - pad)
+        y = max(0, y - pad)
+        cw = min(w - x, cw + 2 * pad)
+        ch = min(h - y, ch + 2 * pad)
+        
+        # Crop
+        cropped = img[y:y+ch, x:x+cw]
+        return cropped
+    return img
+
+
+def run_cropping_pipeline():
+    processed_dir = DATA_DIR / "processed"
+    os.makedirs(processed_dir, exist_ok=True)
+    
+    logger.info("Memulai proses pemotongan (cropping) citra otomatis untuk membersihkan desktop/window borders...")
+    
+    # 1. Proses dataset splits
+    for csv_name in ["train.csv", "val.csv", "test.csv"]:
+        csv_path = os.path.join(SPLITS_DIR, csv_name)
+        if not os.path.exists(csv_path):
+            continue
+            
+        logger.info(f"Memproses {csv_name}...")
+        df = pd.read_csv(csv_path)
+        new_paths = []
+        
+        for idx, row in df.iterrows():
+            orig_path = row['image_path']
+            label = row['label']
+            
+            # Tentukan output path di folder processed
+            filename = os.path.basename(orig_path)
+            out_label_dir = os.path.join(processed_dir, label)
+            os.makedirs(out_label_dir, exist_ok=True)
+            out_path = os.path.join(out_label_dir, filename)
+            
+            # Jika file sudah di-crop sebelumnya, lewati
+            if os.path.exists(out_path):
+                new_paths.append(out_path)
+                continue
+                
+            # Load, crop, dan simpan
+            img = cv2.imread(orig_path)
+            if img is not None:
+                cropped_img = crop_brain_contour(img)
+                cv2.imwrite(out_path, cropped_img)
+                new_paths.append(out_path)
+            else:
+                # Fallback ke path asli jika gagal load
+                new_paths.append(orig_path)
+                
+        df['image_path'] = new_paths
+        df.to_csv(csv_path, index=False)
+        logger.info(f"Selesai memproses {csv_name}. Berkas disimpan kembali dengan path gambar terpotong.")
+ 
+    # 2. Proses folder samples agar berkas tes juga terpotong bersih
+    samples_dir = "samples"
+    if os.path.exists(samples_dir):
+        logger.info("Memproses folder samples...")
+        for filename in os.listdir(samples_dir):
+            if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+                filepath = os.path.join(samples_dir, filename)
+                img = cv2.imread(filepath)
+                if img is not None:
+                    cropped_img = crop_brain_contour(img)
+                    cv2.imwrite(filepath, cropped_img)
+        logger.info("Selesai memproses folder samples.")
+
+
+if __name__ == "__main__":
+    # Setup basic logging to stdout when run directly
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+    run_cropping_pipeline()

prompts.py

@@ -0,0 +1,56 @@
+def build_radiology_prompt(result: dict) -> str:
+    """
+    Membangun prompt untuk Gemini API dalam menyusun laporan radiologi
+    berdasarkan hasil klasifikasi model.
+
+    Args:
+        result: dict berisi predicted_class, confidence, dan visual_summary
+                 (modality, suspected_pattern, attention_region)
+
+    Returns:
+        String prompt siap dikirim ke Gemini API.
+    """
+    predicted_class = result.get("predicted_class", "Tidak diketahui")
+    confidence = result.get("confidence", "N/A")
+    visual = result.get("visual_summary", {})
+    modality = visual.get("modality", "MRI")
+    pattern = visual.get("suspected_pattern", "Tidak tersedia")
+    region = visual.get("attention_region", "Tidak tersedia")
+
+    return f"""Anda adalah asisten AI radiologi yang membantu menyusun draf laporan
+untuk ditinjau oleh Dokter Spesialis Radiologi (Sp.Rad). Anda BUKAN pengganti
+diagnosis dokter — tugas Anda hanya menyusun draf awal berdasarkan data yang
+diberikan sistem.
+
+DATA HASIL ANALISIS SISTEM:
+- Prediksi Penyakit   : {predicted_class}
+- Tingkat Keyakinan   : {confidence}
+- Modalitas Pemeriksaan: {modality}
+- Pola Visual Terdeteksi: {pattern}
+- Area Perhatian (AI)  : {region}
+
+TUGAS:
+Susun draf laporan radiologi dengan struktur berikut:
+
+1. Definisi Penyakit — jelaskan singkat (3-5 kalimat) apa itu {predicted_class}
+   secara umum: definisi medis, penyebab umum, dan siapa yang berisiko
+2. Ringkasan Temuan — deskripsikan temuan utama secara objektif berdasarkan data di atas (2-4 kalimat)
+3. Analisis Klinis — jelaskan makna klinis dari pola visual dan area yang terdeteksi (2-4 kalimat)
+4. Tingkat Keyakinan — interpretasikan confidence score, sebutkan bahwa ini hasil sistem AI (2-3 kalimat)
+5. Tatalaksana Umum — jelaskan pendekatan penanganan/tatalaksana yang UMUM dilakukan
+   untuk kondisi ini sesuai pedoman klinis (bukan resep dosis obat spesifik,
+   karena itu wewenang dokter yang memeriksa langsung), 3-5 kalimat
+6. Rekomendasi Pemeriksaan Lanjutan — sarankan pemeriksaan penunjang yang relevan (2-3 kalimat)
+
+ATURAN:
+- Gunakan bahasa medis formal dan profesional (Bahasa Indonesia)
+- Jangan menyatakan diagnosis sebagai kepastian mutlak — gunakan istilah seperti
+  "mengarah pada", "konsisten dengan", "perlu konfirmasi lebih lanjut"
+- Bagian Tatalaksana Umum harus bersifat edukatif/informatif umum, BUKAN instruksi
+  pengobatan personal untuk pasien tertentu (tidak ada dosis, tidak ada resep spesifik)
+- Wajib tutup laporan dengan catatan bahwa hasil ini adalah opini sekunder AI
+  dan harus divalidasi oleh Dokter Spesialis Radiologi
+- Jangan menambahkan informasi pasien (nama, usia, dll) karena tidak diberikan
+"""  
+  
+