feat: Add initial project structure with Docker support and stroke classification model

- Created Dockerfile with multi-stage build for optimized image size.
- Added docker-compose.yml for service orchestration.
- Introduced Python 3.13 as the project version.
- Implemented model utilities for stroke classification using ONNX.
- Developed Streamlit app for user interface and model interaction.
- Included CSS for styling and assets for sample images.
- Removed requirements.txt in favor of pyproject.toml for dependency management.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/*.png filter=lfs diff=lfs merge=lfs -text

.python-version

@@ -0,0 +1 @@
+3.13

.streamlit/config.toml

@@ -0,0 +1,20 @@
+# Koyu tema: Streamlit’te tamamen kapatma anahtarı yok; iki katman kullanılıyor:
+# 1) toolbarMode = "minimal" → çoğu deployment’da tema menüsü (⋮ Settings) çıkmaz / kısıtlı kalır.
+# 2) [theme.dark] → biri “Dark” veya sistem koyusu seçse bile renkler AÇIK tema ile aynı (görsel koyu yok).
+
+[client]
+toolbarMode = "minimal"
+
+[theme]
+base = "light"
+
+# Streamlit varsayılan LIGHT paleti — "dark" adı altında aynısı (koyu görünüm oluşmaz).
+[theme.dark]
+primaryColor = "#ff4b4b"
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#f0f2f6"
+textColor = "#31333F"
+linkColor = "#0068c9"
+codeTextColor = "#31333F"
+borderColor = "#e6eaf1"
+showWidgetBorder = true

Dockerfile

@@ -1,20 +1,46 @@
-FROM python:3.13.5-slim
+# ==========================================
+# Builder Stage
+# ==========================================
+FROM python:3.13-slim AS builder
+
+# Keep runtime behavior predictable and logs visible in container environments.
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    UV_COMPILE_BYTECODE=1
+
+WORKDIR /app
+
+# Install uv for fast dependency management
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+COPY pyproject.toml uv.lock ./
+
+RUN --mount=type=cache,target=/root/.cache \
+    uv sync --locked --no-dev --no-install-project
+
+# ==========================================
+# Runtime Stage
+# ==========================================
+FROM python:3.13-slim AS runtime
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Runtime uses a non-root user.
+RUN useradd --create-home --shell /usr/sbin/nologin app
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy dependencies and application code
+COPY --from=builder --chown=app:app /app/.venv /app/.venv
+COPY --chown=app:app src ./src
+COPY --chown=app:app assets ./assets
 
-RUN pip3 install -r requirements.txt
+# Ensure runtime entrypoints stay executable
+RUN find /app/.venv/bin -type f -exec chmod 755 {} +
 
+USER app
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Same endpoint as compose: verifies the server responds (slim has no curl).
+HEALTHCHECK --interval=30s --timeout=5s --start-period=45s --retries=3 \
+    CMD ["/app/.venv/bin/python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8501/_stcore/health', timeout=5).read()"]
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["/app/.venv/bin/python", "-m", "streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

docker-compose.yml

@@ -0,0 +1,19 @@
+services:
+  app:
+    build: .
+    ports:
+      - "8501:8501"
+    environment:
+      - STREAMLIT_SERVER_PORT=8501
+    healthcheck:
+      test:
+        [
+          "CMD",
+          "/app/.venv/bin/python",
+          "-c",
+          "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8501/_stcore/health', timeout=5).read()",
+        ]
+      interval: 15s
+      timeout: 5s
+      start_period: 45s
+      retries: 3

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "stroke-classification"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "streamlit>=1.40.0",
+    "pillow>=10.0.0",
+    "numpy>=2.0.0",
+    "onnxruntime>=1.20.0",
+    "huggingface-hub>=0.26.0",
+]

requirements.txt

@@ -1,3 +0,0 @@
-altair
-pandas
-streamlit

src/model_utils.py

@@ -0,0 +1,58 @@
+import os
+from typing import Any
+
+import numpy as np
+import onnxruntime as ort
+from huggingface_hub import hf_hub_download
+from PIL import Image
+
+IMAGE_SIZE = 299
+CLASS_NAMES = ("No-Stroke", "Stroke")
+REPO_ID = os.environ.get("STROKE_MODEL_REPO", "melisklc0/efficientnet-b0-stroke-distilled")
+ONNX_FILENAME = "model.onnx"
+
+
+def _softmax(x: np.ndarray) -> np.ndarray:
+    x = x.astype(np.float64)
+    x = x - np.max(x, axis=-1, keepdims=True)
+    e = np.exp(x)
+    return (e / e.sum(axis=-1, keepdims=True)).astype(np.float32)
+
+
+def preprocess_image(img: Image.Image, image_size: int = IMAGE_SIZE) -> np.ndarray:
+    """RGB, resize, ImageNet normalize -> NCHW float32."""
+    rgb = img.convert("RGB").resize((image_size, image_size), Image.Resampling.BILINEAR)
+    arr = np.asarray(rgb, dtype=np.float32) / 255.0
+    arr = np.transpose(arr, (2, 0, 1))
+    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32).reshape(3, 1, 1)
+    std = np.array([0.229, 0.224, 0.225], dtype=np.float32).reshape(3, 1, 1)
+    arr = (arr - mean) / std
+    return np.expand_dims(arr, axis=0)
+
+
+def load_stroke_model():
+    """Download ONNX from the model Hub repo and build an inference session."""
+    onnx_path = hf_hub_download(
+        repo_id=REPO_ID,
+        filename=ONNX_FILENAME,
+        repo_type="model",
+    )
+    providers: list[str] = ["CPUExecutionProvider"]
+    if ort.get_device() == "GPU":
+        providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
+    session = ort.InferenceSession(onnx_path, providers=providers)
+    return session, preprocess_image
+
+
+def predict(session: ort.InferenceSession, preprocess: Any, img: Image.Image):
+    x = preprocess(img)
+    inp = session.get_inputs()[0].name
+    logits = session.run(None, {inp: x})[0]
+    probs = _softmax(logits[0])
+
+    results = {CLASS_NAMES[i]: float(probs[i]) for i in range(len(CLASS_NAMES))}
+    pred_idx = int(np.argmax(probs))
+    prediction = CLASS_NAMES[pred_idx]
+    confidence = float(probs[pred_idx])
+
+    return prediction, confidence, results

src/static/app.css

@@ -0,0 +1,388 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+
+html, body, [class*="css"] {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+}
+
+.stApp {
+    background-color: #f1f5f9;
+}
+
+.block-container {
+    padding-top: 1.5rem;
+    padding-bottom: 2rem;
+    max-width: 1100px;
+}
+
+section[data-testid="stSidebar"] {
+    background-color: #ffffff;
+    border-right: 1px solid #e2e8f0;
+}
+
+section[data-testid="stSidebar"] .block-container {
+    padding-top: 1.5rem;
+}
+
+.brand-block {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    margin-bottom: 1.5rem;
+}
+
+.brand-mark {
+    width: 44px;
+    height: 44px;
+    border-radius: 10px;
+    background: linear-gradient(145deg, #0f2b46, #1a5f8a);
+    color: #fff;
+    font-weight: 700;
+    font-size: 0.85rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    letter-spacing: -0.02em;
+}
+
+.brand-title {
+    font-size: 1rem;
+    font-weight: 700;
+    color: #0f172a;
+    line-height: 1.2;
+}
+
+.brand-sub {
+    font-size: 0.75rem;
+    color: #64748b;
+    margin-top: 2px;
+}
+
+.info-card {
+    background: #f8fafc;
+    border: 1px solid #e2e8f0;
+    border-radius: 10px;
+    padding: 1rem;
+    margin-bottom: 1.25rem;
+}
+
+.info-card dt {
+    font-size: 0.7rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: #64748b;
+    margin: 0.75rem 0 0.15rem;
+}
+
+.info-card dt:first-child {
+    margin-top: 0;
+}
+
+.info-card dd {
+    margin: 0;
+    font-size: 0.875rem;
+    color: #0f172a;
+    font-weight: 500;
+}
+
+.info-card .metrics-dd {
+    margin-top: 0.1rem;
+}
+
+.info-card .metrics-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0.35rem 1rem;
+    margin: 0;
+    padding: 0;
+}
+
+.info-card .metrics-grid__cell {
+    display: flex;
+    justify-content: space-between;
+    align-items: baseline;
+    gap: 0.5rem;
+    font-size: 0.875rem;
+    line-height: 1.4;
+}
+
+.info-card .metrics-grid__label {
+    color: #64748b;
+    font-weight: 500;
+}
+
+.info-card .metrics-grid__value {
+    color: #0f172a;
+    font-weight: 600;
+    font-variant-numeric: tabular-nums;
+}
+
+.app-header {
+    background: linear-gradient(120deg, #0f2b46 0%, #164e73 55%, #1a5f8a 100%);
+    border-radius: 12px;
+    padding: 1.75rem 2rem;
+    margin-bottom: 1.5rem;
+    color: #ffffff;
+}
+
+.app-header h1 {
+    margin: 0;
+    font-size: 1.65rem;
+    font-weight: 700;
+    color: #ffffff !important;
+    letter-spacing: -0.02em;
+}
+
+.app-header p {
+    margin: 0.4rem 0 0;
+    color: #cbd5e1;
+    font-size: 0.95rem;
+    font-weight: 400;
+}
+
+.verdict-box {
+    border-radius: 10px;
+    padding: 1.25rem 1.5rem;
+    margin-bottom: 1rem;
+    text-align: center;
+}
+
+.verdict-box.stroke {
+    background: #fef2f2;
+    border: 1px solid #fecaca;
+}
+
+.verdict-box.normal {
+    background: #f0fdf4;
+    border: 1px solid #bbf7d0;
+}
+
+.verdict-label {
+    font-size: 0.7rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    color: #64748b;
+    margin-bottom: 0.35rem;
+}
+
+.verdict-value {
+    font-size: 1.75rem;
+    font-weight: 700;
+    letter-spacing: 0.04em;
+}
+
+.verdict-box.stroke .verdict-value { color: #b91c1c; }
+.verdict-box.normal .verdict-value { color: #15803d; }
+
+.prob-chart {
+    margin-top: 0.25rem;
+}
+
+.prob-row {
+    margin-bottom: 0.85rem;
+}
+
+.prob-row:last-child {
+    margin-bottom: 0;
+}
+
+.prob-row__label {
+    margin: 0 0 0.4rem;
+    font-size: 0.875rem;
+    color: #334155;
+}
+
+.prob-row__label strong {
+    font-weight: 600;
+}
+
+.prob-track {
+    height: 10px;
+    background: #e2e8f0;
+    border-radius: 5px;
+    overflow: hidden;
+}
+
+.prob-fill {
+    height: 10px;
+    border-radius: 5px;
+    transition: width 0.25s ease;
+}
+
+.alert-box {
+    border-radius: 8px;
+    padding: 0.85rem 1rem;
+    font-size: 0.85rem;
+    line-height: 1.55;
+    margin: 0.75rem 0.15rem 1rem;
+}
+
+.alert-box--muted {
+    background: #f8fafc;
+    border: 1px solid #e2e8f0;
+    color: #475569;
+}
+
+.hint-box {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.6rem;
+    background: #f8fafc;
+    border: 1px solid #e2e8f0;
+    border-radius: 8px;
+    padding: 0.7rem 0.9rem;
+    margin: 0.35rem 0 1.25rem;
+    font-size: 0.85rem;
+    line-height: 1.45;
+    color: #475569;
+}
+
+.hint-box--ready {
+    background: #f0fdf4;
+    border-color: #bbf7d0;
+    color: #166534;
+}
+
+.hint-box--loading {
+    background: #f8fafc;
+    border-color: #e2e8f0;
+}
+
+.hint-box__icon {
+    flex-shrink: 0;
+    font-size: 1rem;
+    line-height: 1.45;
+}
+
+.hint-box__sub {
+    display: block;
+    font-size: 0.78rem;
+    color: #64748b;
+    margin-top: 0.15rem;
+    font-weight: 400;
+}
+
+.hint-box--ready .hint-box__sub {
+    color: #15803d;
+}
+
+.hint-box strong {
+    font-weight: 600;
+}
+
+.welcome-panel {
+    background: #f8fafc;
+    border: 1px solid #e2e8f0;
+    border-radius: 8px;
+    padding: 1rem 1.2rem 1.4rem;
+    margin: 0.85rem 0.15rem 1rem;
+    font-size: 0.85rem;
+    color: #475569;
+    line-height: 1.5;
+}
+
+.welcome-panel__title {
+    display: block;
+    color: #0f2b46;
+    font-size: 0.9rem;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+}
+
+.welcome-panel__list {
+    margin: 0;
+    padding-left: 1.25rem;
+}
+
+.welcome-panel__list li {
+    margin-bottom: 0.25rem;
+    padding-left: 0.15rem;
+}
+
+.welcome-panel__list li:last-child {
+    margin-bottom: 0;
+}
+
+.empty-state {
+    color: #64748b;
+    font-size: 0.875rem;
+    line-height: 1.55;
+    padding: 0.75rem 0.5rem 1.35rem;
+    margin: 0;
+    text-align: center;
+}
+
+div[data-testid="stVerticalBlockBorderWrapper"] {
+    padding-bottom: 1.75rem;
+}
+
+div[data-testid="stVerticalBlockBorderWrapper"] [data-testid="stVerticalBlock"] {
+    gap: 0.75rem;
+}
+
+.sidebar-disclaimer {
+    background: #fffbeb;
+    border: 1px solid #fde68a;
+    border-radius: 8px;
+    padding: 0.85rem 0.95rem;
+    margin-top: 1.75rem;
+    font-size: 0.75rem;
+    line-height: 1.5;
+    color: #92400e;
+}
+
+.sidebar-disclaimer__label {
+    font-size: 0.65rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: #b45309;
+    margin: 0 0 0.4rem;
+}
+
+.sidebar-disclaimer p:last-child {
+    margin: 0;
+}
+
+.footer-note {
+    text-align: center;
+    color: #94a3b8;
+    font-size: 0.75rem;
+    margin-top: 1.5rem;
+    line-height: 1.6;
+}
+
+h2, h3 {
+    color: #0f172a !important;
+    font-weight: 600 !important;
+}
+
+section[data-testid="stSidebar"] .stButton > button {
+    width: 100%;
+    background: #ffffff;
+    color: #1e4d6e;
+    border: 1px solid #cbd5e1;
+    border-radius: 8px;
+    font-weight: 500;
+    font-size: 0.8rem;
+    padding: 0.45rem 0.5rem;
+    transition: background 0.15s ease, border-color 0.15s ease;
+}
+
+section[data-testid="stSidebar"] .stButton > button:hover {
+    background: #f8fafc;
+    border-color: #94a3b8;
+    color: #0f2b46;
+}
+
+[data-testid="stFileUploader"] section {
+    border: 1px dashed #cbd5e1;
+    border-radius: 10px;
+    background: #f8fafc;
+}
+
+[data-testid="stMetricValue"] {
+    font-size: 1.75rem !important;
+    color: #0f2b46 !important;
+}

src/streamlit_app.py

@@ -1,40 +1,278 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+import os
+from pathlib import Path
+
 import streamlit as st
+from PIL import Image
+
+from model_utils import load_stroke_model, predict
+
+_STATIC_DIR = Path(__file__).resolve().parent / "static"
+_APP_CSS_PATH = _STATIC_DIR / "app.css"
+
+# KD EfficientNet-B0 · 3-fold CV mean (thesis/results/kd/KD_Efficientnet_b0)
+_MODEL_METRICS = {
+    "accuracy": 98.0,
+    "precision": 99.5,
+    "recall": 96.4,
+    "f1": 98.0,
+}
+
+st.set_page_config(
+    page_title="Stroke Classification | Clinical Support",
+    page_icon="🩺",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+
+@st.cache_data
+def _load_app_css() -> str:
+    if not _APP_CSS_PATH.is_file():
+        raise FileNotFoundError(f"Stylesheet not found: {_APP_CSS_PATH}")
+    return _APP_CSS_PATH.read_text(encoding="utf-8")
+
+
+def inject_app_styles() -> None:
+    st.markdown(f"<style>{_load_app_css()}</style>", unsafe_allow_html=True)
+
+
+@st.cache_resource(show_spinner=False)
+def get_model():
+    return load_stroke_model()
+
+
+def _resolve_input_image(file_source):
+    if file_source is not None:
+        st.session_state.pop("sample_path", None)
+        return Image.open(file_source).convert("RGB"), "upload"
+
+    sample_path = st.session_state.get("sample_path")
+    if sample_path and os.path.isfile(sample_path):
+        return Image.open(sample_path).convert("RGB"), "sample"
+
+    if sample_path:
+        st.session_state.pop("sample_path", None)
+    return None, None
+
+
+def _render_probability_bars(results: dict[str, float]) -> None:
+    colors = {"No-Stroke": "#15803d", "Stroke": "#b91c1c"}
+    rows = []
+    for cls in ("No-Stroke", "Stroke"):
+        prob = results.get(cls, 0.0)
+        pct = prob * 100
+        color = colors[cls]
+        rows.append(
+            f'<div class="prob-row">'
+            f'<p class="prob-row__label">{cls} — {prob:.1%}</p>'
+            f'<div class="prob-track">'
+            f'<div class="prob-fill" style="width:{pct:.1f}%;background:{color};"></div>'
+            f"</div></div>"
+        )
+    st.html(f'<div class="prob-chart">{"".join(rows)}</div>')
+
+
+def _sidebar_specs_html() -> str:
+    m = _MODEL_METRICS
+    return f"""
+    <dl class="info-card">
+        <dt>Model</dt>
+        <dd>EfficientNet-B0 (Distilled)</dd>
+        <dt>Metrics</dt>
+        <dd class="metrics-dd">
+            <div class="metrics-grid" aria-label="Model metrics">
+                <div class="metrics-grid__cell">
+                    <span class="metrics-grid__label">Accuracy</span>
+                    <span class="metrics-grid__value">{m["accuracy"]:.1f}%</span>
+                </div>
+                <div class="metrics-grid__cell">
+                    <span class="metrics-grid__label">Precision</span>
+                    <span class="metrics-grid__value">{m["precision"]:.1f}%</span>
+                </div>
+                <div class="metrics-grid__cell">
+                    <span class="metrics-grid__label">Recall</span>
+                    <span class="metrics-grid__value">{m["recall"]:.1f}%</span>
+                </div>
+                <div class="metrics-grid__cell">
+                    <span class="metrics-grid__label">F1</span>
+                    <span class="metrics-grid__value">{m["f1"]:.1f}%</span>
+                </div>
+            </div>
+        </dd>
+        <dt>Training data</dt>
+        <dd>MOH Turkey (15k Augmented Scans)</dd>
+        <dt>External validation</dt>
+        <dd>Kaggle hold-out set</dd>
+    </dl>
+    """
+
+
+def _model_loading_html() -> str:
+    return """
+    <div class="hint-box hint-box--loading">
+        <span class="hint-box__icon">⏳</span>
+        <span>
+            <strong>Loading model</strong>
+            <span class="hint-box__sub">Downloading weights from Hugging Face…</span>
+        </span>
+    </div>
+    """
+
+
+def _model_ready_html() -> str:
+    return """
+    <div class="hint-box hint-box--ready">
+        <span class="hint-box__icon">✅</span>
+        <span><strong>Model ready</strong> — waiting for a scan</span>
+    </div>
+    """
+
+
+def _ensure_model_loaded(status_slot):
+    if st.session_state.get("model_bundle") is not None:
+        status_slot.markdown(_model_ready_html(), unsafe_allow_html=True)
+        return st.session_state.model_bundle
+
+    status_slot.markdown(_model_loading_html(), unsafe_allow_html=True)
+    try:
+        bundle = get_model()
+    except Exception as e:
+        st.error(f"Model could not be loaded: {e}")
+        st.stop()
+
+    st.session_state.model_bundle = bundle
+    status_slot.markdown(_model_ready_html(), unsafe_allow_html=True)
+    return bundle
+
+
+inject_app_styles()
+
+# --- Sidebar ---
+with st.sidebar:
+    st.markdown(
+        """
+        <div class="brand-block">
+            <div class="brand-mark">SC</div>
+            <div>
+                <div class="brand-title">Stroke Classification</div>
+                <div class="brand-sub">Clinical decision support</div>
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+    st.markdown(_sidebar_specs_html(), unsafe_allow_html=True)
+    st.markdown("**Validation Samples**")
+    st.caption("Test cases from the external dataset.")
+    if st.button("Stroke", use_container_width=True):
+        st.session_state.sample_path = "assets/sample_stroke.png"
+    if st.button("No Stroke", use_container_width=True):
+        st.session_state.sample_path = "assets/sample_no_stroke.png"
+
+    st.markdown(
+        """
+        <div class="sidebar-disclaimer">
+            <p class="sidebar-disclaimer__label">Disclaimer</p>
+            <p>For research and decision support only — not a standalone diagnostic device.
+            A qualified clinician must interpret all findings.</p>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+# --- Header (render immediately so the page is not blank) ---
+st.markdown(
+    """
+    <div class="app-header">
+        <h1>Stroke Detection</h1>
+        <p>AI-assisted CT review powered by knowledge-distilled EfficientNet-B0</p>
+    </div>
+    """,
+    unsafe_allow_html=True,
+)
+
+scan_col, result_col = st.columns([1, 1], gap="large")
+
+with scan_col:
+    with st.container(border=True):
+        st.subheader("CT scan")
+        file_source = st.file_uploader(
+            "Upload a non-contrast or contrast-enhanced axial slice (PNG, JPG).",
+            type=["png", "jpg", "jpeg"],
+            label_visibility="collapsed",
+        )
+        input_image, source_kind = _resolve_input_image(file_source)
+
+        if input_image is not None:
+            caption = "Uploaded scan" if source_kind == "upload" else "Kaggle hold-out sample"
+            st.image(input_image, caption=caption, width="stretch")
+        else:
+            st.markdown(
+                """
+                <div class="welcome-panel">
+                    <span class="welcome-panel__title">Get started</span>
+                    <ul class="welcome-panel__list">
+                        <li>Upload a CT slice (PNG or JPG)</li>
+                        <li>Pick a sample from the sidebar</li>
+                    </ul>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+with result_col:
+    with st.container(border=True):
+        st.subheader("Analysis")
+
+        model_status = st.empty()
+        model, transform = _ensure_model_loaded(model_status)
+
+        if input_image is None:
+            st.markdown(
+                '<p class="empty-state">'
+                "Results will appear here after you upload an image or select a sample."
+                "</p>",
+                unsafe_allow_html=True,
+            )
+        else:
+            model_status.empty()
+            with st.spinner("Running inference…"):
+                prediction, confidence, results = predict(model, transform, input_image)
+
+            is_stroke = prediction == "Stroke"
+            verdict_class = "stroke" if is_stroke else "normal"
+            verdict_text = "Stroke detected" if is_stroke else "No stroke detected"
+
+            st.markdown(
+                f"""
+                <div class="verdict-box {verdict_class}">
+                    <div class="verdict-label">Classification</div>
+                    <div class="verdict-value">{verdict_text.upper()}</div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+            st.metric("Model confidence", f"{confidence:.1%}")
+            st.markdown("**Class probabilities**")
+            _render_probability_bars(results)
+
+            note = (
+                "Pattern indicates hemorrhage or ischemia. Clinical review required."
+                if is_stroke
+                else "No stroke pattern detected. Clinical review required."
+            )
+            st.markdown(
+                f'<div class="alert-box alert-box--muted">{note}</div>',
+                unsafe_allow_html=True,
+            )
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.markdown(
+    """
+    <p class="footer-note">
+        Stroke Classification System · Melis Kılıç &amp; Esra Koç<br>
+        ONNX inference · Streamlit
+    </p>
+    """,
+    unsafe_allow_html=True,
+)